Merge branch 'maint'

1 files changed, 429 insertions, 552 deletions

diff --git a/HOWTO/INSTALL-WIN32.md b/HOWTO/INSTALL-WIN32.md
index 79d89551c0..067c939d7a 100644
--- a/HOWTO/INSTALL-WIN32.md
+++ b/HOWTO/INSTALL-WIN32.md
@@ -4,82 +4,110 @@ How to Build Erlang/OTP on Windows
 Introduction
 ------------
 
-This file describes how to build the Erlang emulator and the OTP
-libraries on Windows. The instructions apply to versions of Windows
-supporting the Cygwin emulated gnuish environment for Windows or the
-Msys ditto. We've built on the following platforms: Windows 2003
-server, Windows XP Home/Professional, Windows Vista and Windows 7 (32
-and 64 bit). You can probably build on Windows 2000, but you will not
-be able to install the latest Microsoft SDK, so you have to go back to
-some earlier compiler. Any Windows95'ish platform will surely get you
-into trouble, what I'm not sure of, but it certainly will...
-
-The procedure described uses either Cygwin or Msys as a build
-environment, you run the bash shell in Cygwin/Msys and use gnu
-make/configure/autoconf etc to do the build. The emulator C-source
-code is, however, mostly compiled with Microsoft Visual C++™,
-producing a native Windows binary. This is the same procedure as we
-use to build the pre-built binaries. The fact that we use VC++ and not
-gcc is explained further in the FAQ section.
-
-I describe the build procedure to make it possible for open source
-customers to build the emulator, given that they have the needed
-tools. The binary Windows releases is still a preferred alternative if
-one does not have Microsoft's development tools and/or don't want to
-install Cygwin or Msys.
-
-To use Cygwin/Msys, one needs basic experience from a Unix environment, if
-one does not know how to set environment variables, run programs etc
-in a Unix environment, one will be quite lost in the Cygwin os Msys
-ditto. I can unfortunately not teach all the world how to use
-Cygwin and bash, neither how to install Cygwin nor perform basic tasks
-on a computer. Please refer to other documentation on the net for
-help, or use the binary release instead if you have problems using the
-tools.
-
-However, if you feel comfortable with the environment and build
+This section describes how to build the Erlang emulator and the OTP 
+libraries on Windows. Note that the Windows binary releases are still 
+a preferred alternative if one does not have Microsoft’s development 
+tools and/or don’t want to install Cygwin, MSYS or MSYS2.
+
+The instructions apply to versions of Windows supporting the Cygwin 
+emulated gnuish environment or the MSYS or MSYS2 ditto. We’ve built on 
+the following platforms: Windows 2012, Windows 7, Windows 8 and Windows 10. 
+It’s probably possible to build on older platforms too, but you might 
+not be able to install the appropriate Microsoft SDK, Visual Studio or 
+OpenSSL, in which case you will need to go back to earlier compilers etc.  
+
+The procedure described uses either Cygwin, MSYS or MSYS2 as a build 
+environment. You run the bash shell in Cygwin/MSYS/MSYS2 and use the gnu 
+make/configure/autoconf etc to do the build. The emulator C-source code 
+is, however, mostly compiled with Microsoft Visual C++™, producing a 
+native Windows binary. This is the same procedure as we use to build the 
+pre-built binaries. Why we use VC++ and not gcc is explained further in 
+the FAQ section. 
+
+If you are not familiar with Cygwin, MSYS, MSYS2 or a Unix environment, 
+you’ll probably need to read up a bit on how that works. There are plenty of 
+documentation about this online.
+
+These instructions apply for both 32-bit and 64-bit Windows. Note that even 
+if you build a 64-bit version of Erlang, most of the directories and files 
+involved are still named win32. Some occurances of the name win64 are 
+however present. The installation file for a 64-bit Windows version of 
+Erlang, for example, is `otp_win64_%OTP-REL%.exe`.
+
+If you feel comfortable with the environment and build
 system, and have all the necessary tools, you have a great opportunity
 to make the Erlang/OTP distribution for Windows better. Please submit
-any suggestions and patches to the appropriate [mailing lists] [1] to let
+any suggestions to our [JIRA] [2] and patches to our [git project] [3] to let
 them find their way into the next version of Erlang. If making changes
 to the build system (like makefiles etc) please bear in mind that the
 same makefiles are used on Unix/VxWorks, so that your changes
-don't break other platforms. That of course goes for C-code too, system
+don't break other platforms. That of course goes for C-code too; system
 specific code resides in the `$ERL_TOP/erts/emulator/sys/win32` and
 `$ERL_TOP/erts/etc/win32` directories mostly. The
 `$ERL_TOP/erts/emulator/beam` directory is for common code.
 
-Before the R9C release of Erlang/OTP, the Windows release was built
-partly on a Unix (Solaris) box and partly on a Windows box, using Perl
-hacks to communicate and sync between the two machines. R9C was the
-first release ever built solely on Windows, where no Unix machine is
-needed at all. Now we've used this build procedure for a couple of
+We've used this build procedure for a couple of
 releases, and it has worked fine for us. Still, there might be all
 sorts of troubles on different machines and with different
-setups. I'll try to give hints wherever I've encountered difficulties,
+setups. We'll try to give hints wherever we've encountered difficulties,
 but please share your experiences by using the [erlang-questions] [1]
-mailing list. I cannot of course help everyone with all
-their problems, please try to solve the problems and submit
-solutions/workarounds. Remember, it's all about sharing, not about
-demanding...
-
-Starting with R15B, our build system runs both on Cygwin and Msys
-(MinGW's fork of an early cygwin version). Msys is a smaller package
-to install and may on some machines run slightly faster. If Cygwin
-gives you trouble, try Msys instead, and v.v. Beginning with R15B
-there is also a native 64bit version of Erlang for 64bit Windows 7
-(only). These instructions apply to both the 32bit VM and the 64bit
-ditto.
-
-Note that even if you build a 64bit VM, most of the directories and
-files involved are still named win32. You can view the name win32 as
-meaning any windows version not beeing 16bit. A few occurences of the
-name Win64 are however present in the system, for example the
-installation file for a 64 bit windows version of Erlang is by default
-named `otp_win64_<version>.exe`.
-
-Lets go then, I'll start with a little FAQ, based on in house questions
-and misunderstandings.
+mailing list. We cannot, of course, help everyone with all
+their issues, so please try to solve such issues and submit
+solutions/workarounds.
+
+Lets go then! We’ll start with a short version of the setup procedure, 
+followed by some FAQ, and then we’ll go into more details of the setup. 
+
+
+Short Version
+--------------------------
+In the following sections, we've described as much as we could about the 
+installation of the tools needed. Once the tools are installed, building 
+is quite easy. We have also tried to make these instructions understandable 
+for people with limited Unix experience. Cygwin/MSYS/MSYS2 is a whole new 
+environment to some Windows users, why careful explanation of environment 
+variables etc seemed to be in place. 
+
+This is the short story though, for the experienced and impatient:
+
+    *   Get and install complete Cygwin (latest), complete MinGW with MSYS or 
+        complete MSYS2
+
+    *   Install Visual Studio 12.0 (2013)
+
+    *   Install Microsofts Windows SDK 8.1 
+
+    *   Get and install Sun's JDK 1.6.0 or later
+
+    *   Get and install NSIS 2.01 or later (up to 2.46 tried and working)
+
+    *   Get, build and install OpenSSL 0.9.8r or later (up to 1.0.2d
+        tried & working) with static libs.
+
+    *   Get the Erlang source distribution (from
+        <http://www.erlang.org/download.html>) and unpack with 
+        Cygwin's/MSYS's/MSYS2's `tar`.
+
+    *   Set `ERL_TOP` to where you unpacked the source distribution
+
+    *   `$ cd $ERL_TOP`
+
+    *   Modify PATH and other environment variables so that all these tools
+        are runnable from a bash shell. Still standing in `$ERL_TOP`, issue
+        the following commands (for 32-bit Windows, remove the x64 from the 
+        first row and change `otp_win64_%OTP-REL%` to `otp_win32_%OTP-REL%` on
+        the last row):
+
+            $ eval `./otp_build env_win32 x64`
+            $ ./otp_build autoconf
+            $ ./otp_build configure
+            $ ./otp_build boot -a
+            $ ./otp_build release -a
+            $ ./otp_build installer_win32
+            $ release/win32/otp_win64_%OTP-REL% /S
+
+    Voila! `Start->Programs->Erlang OTP %OTP-REL%->Erlang` starts the Erlang
+    Windows shell.
 
 
 Frequently Asked Questions
@@ -88,12 +116,12 @@ Frequently Asked Questions
 *   Q: So, now I can build Erlang using GCC on Windows?
 
     A: No, unfortunately not. You'll need Microsoft's Visual C++
-    still, a Bourne-shell script (cc.sh) wraps the Visual C++ compiler
+    still. A Bourne-shell script (cc.sh) wraps the Visual C++ compiler
     and runs it from within the Cygwin environment. All other tools
     needed to build Erlang are free-ware/open source, but not the C
     compiler. The Windows SDK is however enough to build Erlang, you
     do not need to buy Visual C++, just download the SDK (SDK version
-    7.1 == Visual studio 2010).
+    8.1 == Visual studio 2013).
 
 *   Q: Why haven't you got rid of VC++ then, you \*\*\*\*\*\*?
 
@@ -106,18 +134,17 @@ Frequently Asked Questions
     mingw build will possibly be back, but as long as VC++ gives better
     performance, the commercial build will be a VC++ one.
 
-*   Q: OK, you need VC++, but now you've started to demand a very recent
-    (and expensive) version of Visual studio, not the old and stable VC++
-    6.0 that was used in earlier versions. Why?
+*   Q: OK, you need VC++, but now you've started to demand a quite recent
+    (and expensive) version of Visual Studio. Why?
 
     A: Well, it's not expensive, it's free (as in free beer). Just
     download and install the latest Windows SDK from Microsoft and all
     the tools you need are there. The included debugger (WinDbg) is
-    also quite usable, it's what I used when porting Erlang to 64bit
-    Windows. Another reason to use the latest Microsoft compilers is
+    also quite usable. That's what I used when porting Erlang to 64bit
+    Windows. Another reason to use later Microsoft compilers is 
     DLL compatibility. DLL's using a new version of the standard
     library might not load if the VM is compiled with an old VC++
-    version, why we should aim to use the latest freely available SDK
+    version. So we should aim to use the latest freely available SDK
     and compiler.
 
 *   Q: Can/will I build a Cygwin binary with the procedure you describe?
@@ -130,9 +157,7 @@ Frequently Asked Questions
     some problems. Fixing those problems might be easy or might be hard.
     I suggest you try yourself and share your experience. No one would be
     happier if a simple `./configure && make` would produce a fully fledged
-    Cygwin binary. Ericsson does however not pay me to do a Cygwin port, so
-    such a port would have to happen in spare time, which is a limited
-    resource...
+    Cygwin binary. 
 
 *   Q: Hah, I saw you, you used GCC even though you said you didn't!
 
@@ -142,7 +167,7 @@ Frequently Asked Questions
     particular file, `beam_emu.c` benefits immensely from being able
     to use the GCC labels-as-values extension, which boosts emulator
     performance by up to 50%. That does unfortunately not (yet) mean
-    that all of OTP could be compiled using GCC, that particular
+    that all of OTP could be compiled using GCC. That particular
     source code does not do anything system specific and actually is
     adopted to the fact that GCC is used to compile it on Windows.
 
@@ -152,229 +177,184 @@ Frequently Asked Questions
     A: No, never. The hassle of keeping the project files up to date and
     do all the steps that constitute an OTP build from within the VC++ GUI
     is simply not worth it, maybe even impossible. A VC++ project
-    file for Erlang/OTP will never happen, at least I will never make
-    one. Clicking around in super-multi-tab'd dialogs to add a file or
-    compiler option when it's so much easier in a makefile is simply not
-    my style.
+    file for Erlang/OTP will never happen.
 
 *   Q: So how does it all work then?
 
-    A: Cygwin or Msys is the environment, which closely resembles the
-    environments found on any Unix machine. It's almost like you had a
+    A: Cygwin, MSYS or MSYS2 is the environment, which closely resembles the
+    environment found on any Unix machine. It's almost like you had a
     virtual Unix machine inside Windows. Configure, given certain
     parameters, then creates makefiles that are used by the
-    Cygwin/Msys gnu-make to built the system. Most of the actual
-    compilers etc are not, however, Cygwin/Msys tools, so I've written
+    environment's gnu-make to built the system. Most of the actual
+    compilers etc are not, however, Cygwin/MSYS/MSYS2 tools, so we've written
     a couple of wrappers (Bourne-shell scripts), which reside in
     `$ERL_TOP/etc/win32/cygwin_tools` and
     `$ERL_TOP/etc/win32/msys_tools`. They all do conversion of
     parameters and switches common in the Unix environment to fit the
     native Windows tools. Most notable is of course the paths, which
-    in Cygwin/Msys are Unix-like paths with "forward slashes" (/) and
-    no drive letters, the Cygwin specific command `cygpath` is used
-    for most of the path conversions in a Cygwin environment, other
-    tools are used (when needed) in the corresponding Msys
+    in Cygwin/MSYS/MSYS2 are Unix-like paths with "forward slashes" (/) and
+    no drive letters. The Cygwin specific command `cygpath` is used
+    for most of the path conversions in a Cygwin environment. Other
+    tools are used (when needed) in the corresponding MSYS and MSYS2
     environment. Luckily most compilers accept forward slashes instead
     of backslashes as path separators, but one still have to get the drive
     letters etc right, though. The wrapper scripts are not general in
-    the sense that, for example, cc.sh would understand and translates
-    every possible gcc option and passes correct options to
+    the sense that, for example, cc.sh would understand and translate
+    every possible gcc option and pass correct options to
     cl.exe. The principle is that the scripts are powerful enough to
     allow building of Erlang/OTP, no more, no less. They might need
-    extensions to cope with changes during the development of Erlang,
-    that's one of the reasons I made them into shell-scripts and not
-    Perl-scripts, I believe they are easier to understand and change
-    that way. I might be wrong though, cause another reason I didn't
-    write them in Perl is because I've never liked Perl and my Perl
-    code is no pleasant reading...
+    extensions to cope with changes during the development of Erlang, and
+    that's one of the reasons we made them into shell-scripts and not
+    Perl-scripts. We believe they are easier to understand and change
+    that way.
 
     In `$ERL_TOP`, there is a script called `otp_build`. That script handles
     the hassle of giving all the right parameters to `configure`/`make` and
     also helps you set up the correct environment variables to work with
-    the Erlang source under Cygwin.
+    the Erlang source under Cygwin/MSYS/MSYS2.
 
 *   Q: You use and need Cygwin, but then you haven't taken the time to
     port Erlang to the Cygwin environment but instead focus on your
     commercial release, is that really ethical?
 
-    A: No, not really, but see this as a step in the right direction. I'm
-    aiming at GCC compiled emulators and a Cygwin version, but I really
-    need to do other things as well... In time, but don't hold your
-    breath...
+    A: No, not really, but see this as a step in the right direction. 
 
 *   Q: Can I build something that looks exactly as the commercial release?
 
-    A: Yes, we use the exactly same build procedure.
+    A: Yes, we use the exact same build procedure.
 
-*   Q: Which version of Cygwin/Msys and other tools do you use then?
+*   Q: Which version of Cygwin/MSYS/MSYS2 and other tools do you use then?
 
-    A: For Cygwin and Msys alike, we try to use the latest releases
+    A: For Cygwin, MSYS and MSYS2 alike, we try to use the latest releases
     available when building. What versions you use shouldn't really
-    matter, I try to include workarounds for the bugs I've found in
-    different Cygwin/Msys releases, please help me add workarounds
-    for new Cygwin/Msys-related bugs as soon as you encounter
-    them. Also please do submit bug reports to the appropriate Cygwin
-    and/or Msys developers. The GCC we used for %OTP-REL% was version
-    4.7.0 (MinGW 64bit) and 4.3.4 (Cygwin 32bit). We used VC++ 10.0
-    (i.e. Visual studio 2010), Sun's JDK 1.5.0\_17 (32bit) and Sun's
-    JDK 1.7.0\_1 (64bit), NSIS 2.46, and Win32 OpenSSL 0.9.8r. Please
+    matter. We try to include workarounds for the bugs we've found in
+    different Cygwin/MSYS/MSYS2 releases. Please help us add workarounds
+    for new Cygwin/MSYS/MSYS2-related bugs as soon as you encounter
+    them. Also please do submit bug reports to the appropriate Cygwin, MSYS
+    and/or MSYS2 developers. The GCC we used for %OTP-REL% was version
+    4.8.1 (MinGW 32bit) and 4.8.5 (MSYS2 64bit). We used  VC++ 12.0 
+    (i.e. Visual studio 2013), Sun's JDK 1.6.0\_45 (32bit) and Sun's
+    JDK 1.7.0\_1 (64bit), NSIS 2.46, and Win32 OpenSSL 1.0.2d. Please
     read the next section for details on what you need.
 
-*   Q: Can you help me setup X in Cygwin?
+*   Q: Can you help me setup X in Cygwin/MSYS/MSYS2?
 
-    A: No, unfortunately I haven't got time to help with Cygwin related
-    user problems, please read Cygwin related web sites, newsgroups and
+    A: No, unfortunately we haven't got time to help with Cygwin/MSYS/MSYS2 
+    related user problems, please read related websites, newsgroups and
     mailing lists.
 
-*   Q: Why is the instruction so long? Is it really that complicated?
-
-    A: Partly it's long because I babble too much, partly because I've
-    described as much as I could about the installation of the needed
-    tools. Once the tools are installed, building is quite easy. I also
-    have tried to make this instruction understandable for people with
-    limited Unix experience. Cygwin/Msys is a whole new environment to some
-    Windows users, why careful explanation of environment variables etc
-    seemed to be in place. The short story, for the experienced and
-    impatient is:
-
-    *   Get and install complete Cygwin (latest) or complete MinGW with msys
-
-    *   Install Microsofts Windows SDK 7.1 (and .Net 4)
-
-    *   Get and install Sun's JDK 1.5.0 or higher
-
-    *   Get and install NSIS 2.01 or higher (up to 2.46 tried and working)
-
-    * Get, build and install OpenSSL 0.9.8r or higher (up to 1.0.0a
-        tried & working) with static libs.
-
-    *   Get the Erlang source distribution (from
-        <http://www.erlang.org/download.html>) and unpack with Cygwin's `tar`.
-
-    *   Set `ERL_TOP` to where you unpacked the source distribution
-
-    *   `$ cd $ERL_TOP`
-
-    *   Get (from <http://www.erlang.org/download/tcltk85_win32_bin.tar.gz>)
-        and unpack the prebuilt TCL/TK binaries for windows with cygwin tar,
-        standing in `$ERL_TOP`
-
-    *   Modify PATH and other environment variables so that all these tools
-        are runnable from a bash shell. Still standing in `$ERL_TOP`, issue
-        the following commands:
-
-            $ eval `./otp_build env_win32`
-            $ ./otp_build autoconf
-            $ ./otp_build configure
-            $ ./otp_build boot -a
-            $ ./otp_build release -a
-            $ ./otp_build installer_win32
-            $ release/win32/otp_win32_%OTP-REL% /S
-
-    Voila! `Start->Programs->Erlang OTP %OTP-REL%->Erlang` starts the Erlang
-    Windows shell.
-
 
 Tools you Need and Their Environment
 ------------------------------------
 
 You need some tools to be able to build Erlang/OTP on Windows. Most
-notably you'll need Cygwin or Msys and Microsofts Windows SDK, but
-you also might want a Java compiler, the NSIS install system and
-OpenSSL. Well' here's the list:
+notably you'll need Cygwin, MSYS or MSYS2, Visual Studio and Microsofts 
+Windows SDK, but you might also want a Java compiler, the NSIS install 
+system and OpenSSL. Well, here's some information about the different 
+tools:
 
 *   Cygwin, the very latest is usually best. Get all the development
-    tools and of course all the basic ditto. In fact getting the complete
-    package might be a good idea, as you'll start to love Cygwin after a
-    while if you're accustomed to Unix. Make sure to get jar and also make
-    sure *not* to install a Cygwin'ish Java... The Cygwin jar command is
-    used but Sun's Java compiler and virtual machine...
+    tools and of course all the basic ditto. Make sure to get jar and 
+    also make sure *not* to install a Cygwin'ish Java, since the Cygwin 
+    jar command is used but Sun's Java compiler and virtual machine.
 
     If you are going to build a 64bit Windows version, you should make
-    sure to get MinGW's 64bit gcc installed with cygwin. It's in one of
+    sure to get MinGW's 64bit gcc installed with Cygwin. It's in one of
     the development packages.
 
     URL: <http://www.cygwin.com>
 
-    Get the installer from the web site and use that to install
-    Cygwin. Be sure to have fair privileges. If you're on a NT domain you
+    Get the installer from the website and use it to install
+    Cygwin. Be sure to have fair privileges. If you're on an NT domain you
     should consider running `mkpasswd -d` and `mkgroup -d` after the
     installation to get the user databases correct. See their respective
     manual pages.
 
-    When you start you first bash shell, you will get an awful prompt. You
+    When you start your first bash shell, you will get an awful prompt. You
     might also have a `PATH` environment variable that contains backslashes
     and such. Edit `$HOME/.profile` and `$HOME/.bashrc` to set fair prompts
-    and set a correct PATH. Also do a `export SHELL` in `.profile`. For some
+    and a correct PATH. Also do an `export SHELL` in `.profile`. For some
     non-obvious reason the environment variable `$SHELL` is not exported in
     bash. Also note that `.profile` is run at login time and `.bashrc` when
     sub shells are created. You'll need to explicitly source `.bashrc` from
     `.profile` if you want the commands there to be run at login time (like
-    setting up aliases, shell functions and the like). I personally
-    usually do like this at the end of `.profile`:
+    setting up aliases, shell functions and the like). You can for example 
+    do like this at the end of `.profile`:
 
         ENV=$HOME/.bashrc
         export ENV
         . $ENV
 
-    You might also, if you're a hard core type of person at least, want to
-    setup X-windows (XFree86), that might be as easy as running startx
-    from the command prompt and it might be much harder. Use Google to
-    find help...
+    You might also want to setup X-windows (XFree86). That might be as easy 
+    as running startx from the command prompt and it might be much harder. 
+    Use Google to find help.
 
     If you don't use X-windows, you might want to setup the Windows
     console window by selecting properties in the console system menu
     (upper left corner of the window, the Cygwin icon in the title
     bar). Especially setting a larger screen buffer size (lines) is useful
     as it gets you a scrollbar so you can see whatever error messages
-    that might appear...
+    that might appear.
 
-    If you want to use (t)csh instead of bash you're on your own, I
-    haven't tried and know of no one that has. I expect
-    that you use bash in all shell examples.
+    There are a few other shells available, but in all examples below we assume
+    that you use bash.
 
-*   Alternatively you download MinGW and Msys. You'll find the latest
+*   Alternatively you download MinGW and MSYS. You'll find the latest
     installer at:
 
     URL: <http://sourceforge.net/projects/mingw/files/Installer/mingw-get-inst/>
 
-    Make sure to install everything they've got. 
+    Make sure to install the basic dev tools, but avoid the MinGW autoconf and
+    install the msys one instead.  
 
     To be able to build the 64bit VM, you will also need the 64bit
     MinGW compiler from:
 
-    URL: <http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Automated%20Builds/>
+    URL: <http://sourceforge.net/projects/mingw-w64/files/latest/download?source=files>
 
-    The latest version should do it. Make sure you download the
-    `mingw-w64-bin_i686-mingw_<something>.zip`, not a linux
+    We've tried up to 1.0, but the latest version should do. Make sure you 
+    download the `mingw-w64-bin_i686-mingw_<something>.zip`, not a linux
     version. You unzip the package on top of your MinGW installation
     (`c:\MinGW`) and that's it.
 
-    Setting up your environment in Msys is similar to setting it up in
-    Cygwin.
+*   A third alternative is to download and install MSYS2 from:
 
-* Microsofts Windows SDK version 7.1 (corresponding to VC++ 10.0 and
-    Visual Studio 2010). You'll find it here:
-    
-    URL: <http://www.microsoft.com/download/en/details.aspx?id=8279>
+    URL: <https://msys2.github.io/>
+
+    When you've followed the instructions there, you also need to install 
+    these packages: autoconf, make, perl, and tar. You do so by running 
+    the following in the msys console:
+
+        pacman -S msys/autoconf msys/make msys/perl msys/tar 
+
+    You also need a gcc. If you installed the 64 bit MSYS2 you run:
 
-    but before you install that, you need to have .Net 4 installed,
-    you'll find that here:
+        mingw64/mingw-w64-x86_64-gcc
 
-    URL: <http://www.microsoft.com/download/en/details.aspx?id=17851>
+    And for 32 bit MSYS2:
 
-    Use the web installer for the SDK, at least when I tried
-    downloading the whole package as an image, I got SDK 7.0 instead,
-    which is not what you want...
+        pacman -S mingw32/mingw-w64-i686-gcc
+        pacman -S mingw-w64-i686-editrights
 
-    There will be a Windows command file in `%PROGRAMFILES%\Mirosoft
-    SDKs\Windows\v7.1\Bin\SetEnv.cmd` that set's the appropriate
+*   Visual Studio 2013 (Visual Studio 12.0). Download and run the web 
+    installer from: 
+
+        https://www.visualstudio.com/
+
+*   Microsofts Windows SDK version 8.1 (corresponding to VC++ 12.0 and
+    Visual Studio 2013). You'll find it here:
+    
+    URL: <https://msdn.microsoft.com/en-us/windows/desktop/bg162891.aspx>
+
+*   To help setup the environment, there is a bat file, 
+    `%PROGRAMFILES%\Mirosoft Visual Studio 12.0\VC\vcvarsall.bat`, 
+    that set's the appropriate
     environment for a Windows command prompt. This is not appropriate
     for bash, so you'll need to convert it to bash-style environments
     by editing your `.bash_profile`. In my case, where the SDK is
     installed in the default directory and `%PROGRAMFILES%` is
     `C:\Program Files`, the commands for setting up a 32bit build
-    environment (on a 64bit or 32bit machine) look like this (in cygwin):
+    environment (on a 64bit or 32bit machine) look like this (in Cygwin):
 
         # Some common paths
         C_DRV=/cygdrive/c
@@ -383,309 +363,290 @@ OpenSSL. Well' here's the list:
         # nsis
         NSIS_BIN=$PRG_FLS/NSIS
         # java
-        JAVA_BIN=$PRG_FLS/Java/jdk1.6.0_16/bin
+        JAVA_BIN=$PROGRAMFILES/Java/jdk1.7.0_02/bin
 
         ##
         ## MS SDK
         ##
 
-        CYGWIN=nowinsymlinks
-        MVS10="$PRG_FILES/Microsoft Visual Studio 10.0"
-        WIN_MVS10="C:\\Program Files\\Microsoft Visual Studio 10.0"
-        SDK10="$PRG_FILES/Microsoft SDKs/Windows/v7.1"
-        WIN_SDK10="C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1"
+        CYGWIN=nowinsymlinks 
+
+        VISUAL_STUDIO_ROOT=$PRG_FLS/Microsoft\ Visual\ Studio\ 12.0
+        WIN_VISUAL_STUDIO_ROOT="C:\\Program Files\\Microsoft Visual Studio 12.0"
+        SDK=$PRG_FLS/Windows\ Kits/8.1
+        WIN_SDK="C:\\Program Files\\Windows Kits\\8.1"
 
         PATH="$NSIS_BIN:\
-        $MVS10/Common7/IDE:\
-        $MVS10/Common7/Tools:\
-        $MVS10/VC/Bin:\
-        $MVS10/VC/Bin/VCPackages:\
-        $SDK10/Bin/NETFX 4.0 Tools:\
-        $SDK10/Bin:\
+        $VISUAL_STUDIO_ROOT/VC/bin:\
+        $VISUAL_STUDIO_ROOT/VC/vcpackages:\
+        $VISUAL_STUDIO_ROOT/Common7/IDE:\
+        $VISUAL_STUDIO_ROOT/Common7/Tools:\
+        $SDK/bin/x86
         /usr/local/bin:/usr/bin:/bin:\
         /cygdrive/c/WINDOWS/system32:/cygdrive/c/WINDOWS:\
         /cygdrive/c/WINDOWS/system32/Wbem:\
         $JAVA_BIN"
 
-        LIBPATH="$WIN_MVS10\\VC\\LIB"
+        LIBPATH="$WIN_VISUAL_STUDIO_ROOT\\VC\\lib"
 
-        LIB="$WIN_MVS10\\VC\\LIB;$WIN_SDK10\\LIB"
+        LIB="$WIN_VISUAL_STUDIO_ROOT\\VC\\lib\\;$WIN_SDK\\lib\\winv6.3\\um\\x86"
 
-        INCLUDE="$WIN_MVS10\\VC\\INCLUDE;$WIN_SDK10\\INCLUDE;$WIN_SDK10\\INCLUDE\\gl"
+        INCLUDE="$WIN_VISUAL_STUDIO_ROOT\\VC\\include\\;$WIN_SDK\\include\\shared\\;
+        $WIN_SDK\\include\\um;$WIN_SDK\\include\\winrt\\;$WIN_SDK\\include\\um\\gl"
 
-        export CYGWIN PATH LIBPATH LIB INCLUDE 
+        export CYGWIN PATH LIBPATH LIB INCLUDE
 
-    If you're using Msys instead, the only thing you need to change is
-    the `C_DRV` setting, which would read:
+    If you're using MinGW's MSYS instead, you need to change the `C_DRV` setting, 
+    which would read:
 
         C_DRV=/c
 
-    And of course you might need to change `C:\Program Files` etc if
-    you're using a non-english version of Windows (XP). Note that in
-    later versions of Windows, the national adoptions of the program
-    files directories etc are not on the file system but only in the
-    explorer, so even if explorer says that your programs reside in
-    e.g. `C:\Program`, they might still reside in `C:\Program Files`
-    in reality...
-
-    If you are building a 64 bit version of Erlang, you should set up
-    PATHs etc a little differently. I use the following script to
-    make things work in both Cygwin and Msys:
-
-         make_winpath()
-         {
-                P=$1
-                if [ "$IN_CYGWIN" = "true" ]; then 
-                   cygpath -d "$P"
-                else
-                   (cd "$P" && /bin/cmd //C "for %i in (".") do @echo %~fsi")
-                fi
-         }
-
-         make_upath()
-         {
-                P=$1
-                if [ "$IN_CYGWIN" = "true" ]; then 
-                   cygpath "$P"
-                else
-                   echo "$P" | /bin/sed 's,^\([a-zA-Z]\):\\,/\L\1/,;s,\\,/,g'
-                fi
-         }
-
-         # Some common paths
-         if [ -x /usr/bin/msysinfo ]; then
-            # Without this the path conversion won't work
-            COMSPEC='C:\Windows\SysWOW64\cmd.exe'
-            MSYSTEM=MINGW32
-            export MSYSTEM COMSPEC
-            IN_CYGWIN=false
-         else
-            CYGWIN=nowinsymlinks
-            export CYGWIN
-            IN_CYGWIN=true
-         fi
-
-         if [ "$IN_CYGWIN" = "true" ]; then 
-            PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:\
-            /cygdrive/c/windows/system32:/cygdrive/c/windows:/cygdrive/c/windows/system32/Wbem
-         else
-            PATH=/usr/local/bin:/mingw/bin:/bin:/c/Windows/system32:/c/Windows:\
-            /c/Windows/System32/Wbem
-         fi
-
-         if [ "$IN_CYGWIN" = "true" ]; then 
-            C_DRV=/cygdrive/c
-         else
-            C_DRV=/c
-         fi
-
-         PRG_FLS64=$C_DRV/Program\ Files
-         PRG_FLS32=$C_DRV/Program\ Files\ \(x86\)
-         VISUAL_STUDIO_ROOT32=$PRG_FLS32/Microsoft\ Visual\ Studio\ 10.0
-         MS_SDK_ROOT64=$PRG_FLS64/Microsoft\ SDKs/Windows/v7.1
-
-         # Okay, now mangle the paths and get rid of spaces by using short names
-         WIN_VCROOT32=`make_winpath "$VISUAL_STUDIO_ROOT32"`
-         VCROOT32=`make_upath $WIN_VCROOT32`
-         WIN_SDKROOT64=`make_winpath "$MS_SDK_ROOT64"`
-         SDKROOT64=`make_upath $WIN_SDKROOT64`
-         WIN_PROGRAMFILES32=`make_winpath "$PRG_FLS32"`
-         PROGRAMFILES32=`make_upath $WIN_PROGRAMFILES32`
-    
-         WIN_PROGRAMFILES64=`make_winpath "$PRG_FLS64"`
-         PROGRAMFILES64=`make_upath $WIN_PROGRAMFILES64`
-
-         # nsis
-         NSIS_BIN=$PROGRAMFILES32/NSIS
-         # java
-         JAVA_BIN=$PROGRAMFILES64/Java/jdk1.7.0_01/bin
-
-         ## The PATH variable should be Unix'ish
-         VCPATH=$VCROOT32/Common7/IDE:$VCROOT32/VC/BIN/amd64:$VCROOT32/Common7/Tools:\
-         $VCROOT32/VC/VCPackages:$SDKROOT64/bin/NETFX4~1.0TO/x64:$SDKROOT64/bin/x64:\
-         $SDKROOT64/bin
-
-         ## Microsoft SDK libs
-
-         LIBPATH=$WIN_VCROOT32\\VC\\LIB\\amd64
-         LIB=$WIN_VCROOT32\\VC\\LIB\\amd64\;$WIN_SDKROOT64\\LIB\\X64
-         INCLUDE=$WIN_VCROOT32\\VC\\INCLUDE\;$WIN_SDKROOT64\\include\;\
-         $WIN_SDKROOT64\\include\\gl
-
-         # Put nsis, c compiler and java in path
-         PATH=$NSIS_BIN:$VCPATH:$PATH:$JAVA_BIN
-
-         # Make sure LIB and INCLUDE is available for others
-         export PATH LIBPATH LIB INCLUDE
-
-    All this is derived from the SetEnv.cmd command file mentioned
-    earlier. The bottom line is to set the PATH so that NSIS and
-    Microsoft SDK is found before the Msys/Cygwin tools and that Java
-    is last in the PATH.
-
-    Make a simple hello world (maybe one that prints out 
-    `sizeof(void *)`) and try to compile it with the `cl` command from within
-    bash. If that does not work, your environment needs fixing. Also
-    remember to fix up the PATH environment, especially old Erlang
-    installations might have inserted quoted paths that Cygwin/Msys
-    does not understand. Remove or correct such paths. There should be
-    no backslashes in your path environment variable in Cygwin bash,
-    but LIB and INCLUDE should contain Windows style paths with
-    semicolon, drive letters and backslashes.
+    and you also need to change the PATH environment variable to: 
 
-*   Sun's Java JDK 1.5.0 or higher. Our Java code (jinterface, ic) is
-    written for JDK 1.5.0. Get it for Windows and install it, the JRE is
-    not enough. If you don't care about Java, you can skip this step, the
-    result will be that jinterface is not built.
+        MINGW_BIN=/c/MinGW/bin
 
-    URL: <http://java.sun.com>
 
-    Add javac *LAST* to your path environment in bash, in my case this means:
+        PATH="$NSIS_BIN:\
+        $VISUAL_STUDIO_ROOT/VC/bin:\
+        $VISUAL_STUDIO_ROOT/VC/vcpackages:\
+        $VISUAL_STUDIO_ROOT/Common7/IDE:\
+        $VISUAL_STUDIO_ROOT/Common7/Tools:\
+        $SDK/bin/x86:/usr/local/bin:\
+        $MINGW_BIN:\
+        /bin:/c/Windows/system32:/c/Windows:\
+        /c/Windows/System32/Wbem:\
+        $JAVA_BIN"
 
-        `PATH="$PATH:/cygdrive/c/Program Files/Java/jdk1.5.0_17/bin"`
+    For MSYS2 you use the same `C_DRV` and PATH as for MSYS, only update the `MINGW_BIN`:
 
-    No `CLASSPATH` or anything is needed. Type `javac` at the bash prompt
-    and you should get a list of available Java options. Make sure by
-    typing `type java` that you use the Java you installed. Note however that
-    Cygwin's `jar.exe` is used, that's why the JDK bin-directory should be
-    added last in the `PATH`.
+        MINGW_BIN=/mingw32/bin
+ 
 
-*   Nullsoft NSIS installer system. You need this to build the self
-    installing package. It's a free open source installer that's much
-    nicer to use than the commercial Wise and Install shield
-    installers. This is the installer we use for commercial releases as
-    well from R9C an on.
+    If you are building a 64 bit version of Erlang, you should set up 
+    PATHs etc a little differently. We have two templates to make things 
+    work in both Cygwin and MSYS but needs editing to work with MSYS2 (see the 
+    comments in the script). 
+    The following one is for 32 bits:
+ 
+        make_winpath()
+        { 
+            P=$1
+            if [ "$IN_CYGWIN" = "true" ]; then
+                cygpath -d "$P"
+            else
+                (cd "$P" && /bin/cmd //C "for %i in (".") do @echo %~fsi")
+            fi
+        }
+
+        make_upath()
+        {
+            P=$1
+            if [ "$IN_CYGWIN" = "true" ]; then
+                cygpath "$P"
+            else
+                echo "$P" | /bin/sed 's,^\([a-zA-Z]\):\\,/\L\1/,;s,\\,/,g'
+            fi
+        }
 
-    URL: <http://www.nullsoft.com/free/nsis>
+        # Some common paths
+        if [ -x /usr/bin/msys-?.0.dll ]; then
+          # Without this the path conversion won't work
+          COMSPEC='C:\Windows\System32\cmd.exe'
+          MSYSTEM=MINGW32  # Comment out this line if in MSYS2
+          export MSYSTEM COMSPEC
+          # For MSYS2: Change /mingw/bin to the msys bin dir on the line below
+          PATH=/usr/local/bin:/mingw/bin:/bin:/c/Windows/system32:\
+          /c/Windows:/c/Windows/System32/Wbem
+          C_DRV=/c
+          IN_CYGWIN=false
+        else
+          PATH=/ldisk/overrides:/usr/local/bin:/usr/bin:/bin:\
+          /usr/X11R6/bin:/cygdrive/c/windows/system32:\
+          /cygdrive/c/windows:/cygdrive/c/windows/system32/Wbem
+          C_DRV=/cygdrive/c
+          IN_CYGWIN=true
+        fi
+
+        obe_otp_gcc_vsn_map="
+            .*=>default 
+        "   
+        obe_otp_64_gcc_vsn_map="
+            .*=>default
+        "
+        # Program Files 
+        PRG_FLS=$C_DRV/Program\ Files
 
-    Install the lot, especially the modern user interface components, as
-    it's definitely needed. Put `makensis` in your path, in my case:
+        # Visual Studio
+        VISUAL_STUDIO_ROOT=$PRG_FLS/Microsoft\ Visual\ Studio\ 12.0
+        WIN_VISUAL_STUDIO_ROOT="C:\\Program Files\\Microsoft Visual Studio 12.0"
 
-        PATH=/cygdrive/c/Program\ Files/NSIS:$PATH
+        # SDK
+        SDK=$PRG_FLS/Windows\ Kits/8.1
+        WIN_SDK="C:\\Program Files\\Windows Kits\\8.1"
 
-    type makensis at the bash prompt and you should get a list of options
-    if everything is OK.
+        # NSIS
+        NSIS_BIN=$PROGRAMFILES/NSIS
 
-* OpenSSL. This is if you want the SSL and crypto applications to
-    compile (and run). There are prebuilt binaries available, but I
-    strongly recommend building this yourself. It's quite easy.
+        # Java 
+        JAVA_BIN=$PROGRAMFILES/Java/jdk1.7.0_02/bin
 
-    First get the source from 
+        ## The PATH variable should be Cygwin'ish
+        VCPATH=
+        $VISUAL_STUDIO_ROOT/VC/bin:\
+        $VISUAL_STUDIO_ROOT/VC/vcpackages:\
+        $VISUAL_STUDIO_ROOT/Common7/IDE:\
+        $VISUAL_STUDIO_ROOT/Common7/Tools:\
+        $SDK/bin/x86
 
-    URL: <http://openssl.org/source/>
+        ## Microsoft SDK libs
+        LIBPATH=$WIN_VISUAL_STUDIO_ROOT\\VC\\lib
 
-    I would recommend using 0.9.8r. 
+        LIB=$WIN_VISUAL_STUDIO_ROOT\\VC\\lib\\;$WIN_KITS\\lib\\winv6.3\\um\\x86
 
-    Download the tar file and unpack it (using your bash prompt) into
-    a directory of your choise.
+        INCLUDE=$WIN_VISUAL_STUDIO_ROOT\\VC\\include\\;\
+        $WIN_KITS\\include\\shared\\;$WIN_KITS\\include\\um;\
+        $WIN_KITS\\include\\winrt\\;$WIN_KITS\\include\\um\\gl
 
-    You will need a Windowish Perl for the build. ActiveState has one:
+        # Put nsis, c compiler and java in path
+        export PATH=$VCPATH:$PATH:$JAVA_BIN:$NSIS_BIN
 
-    URL: <http://www.activestate.com/activeperl/downloads>
+        # Make sure LIB and INCLUDE is available for others
+        export LIBPATH LIB INCLUDE
 
-    Download and install that. Disable options to associate it with
-    the .pl suffix and/or adding things to PATH, they are not needed. 
 
-    Now fire up the Microsoft Windows SDK command prompt in RELEASE
-    mode for the architecture you are going to build. The easiest is
-    to copy the shortcut from the SDKs start menu item and edit the
-    command line in the shortcut (Right click->Properties) to end with
-    `/Release`. Make sure the banner when you double click your
-    shortcut (the text in the resulting command window) says
-    `Targeting Windows XP x64 Release` if you are going to do a 64 bit
-    build and `Targeting Windows XP x86 Release` if you are building a
-    32 bit version.
 
-    Now cd to where you unpacked the OpenSSL source using your Release
-    Windows command prompt (it should be on the same drive as where
-    you are going to install it if everything is to work smothly).
+    The first part of the 64 bit template is identical to the 32 bit one, 
+    but there are some environment variable differences: 
 
-        C:\> cd <some dir>
+        # Program Files
+        PRG_FLS64=$C_DRV/Program\ Files
+        PRG_FLS32=$C_DRV/Program\ Files\ \(x86\)
 
-    Add ActiveState (or some other windows perl, not cygwins) to your PATH:
+        # Visual Studio
+        VISUAL_STUDIO_ROOT=$PRG_FLS32/Microsoft\ Visual\ Studio\ 12.0
+        WIN_VISUAL_STUDIO_ROOT="C:\\Program Files (x86)\\Microsoft Visual Studio 12.0"
 
-        C:\...\> set PATH=C:\Perl\bin;%PATH%
+        # SDK
+        SDK=$PRG_FLS32/Windows\ Kits/8.1
+        WIN_SDK="C:\\Program Files (x86)\\Windows Kits\\8.1"
 
-    Or if you installed the 64bit perl:
-    
-        C:\...\> set PATH=C:\Perl64\bin;%PATH%
+        # NSIS
+        NSIS_BIN=$PROGRAMFILES/NSIS
+        # Java 
+        JAVA_BIN=$PROGRAMFILES/Java/jdk1.7.0_02/bin
 
-    Configure OpenSSL for 32 bit:
+        ## The PATH variable should be Cygwin'ish
+        VCPATH=
+        $VISUAL_STUDIO_ROOT/VC/bin/amd64:\
+        $VISUAL_STUDIO_ROOT/VC/vcpackages:\
+        $VISUAL_STUDIO_ROOT/Common7/IDE:\
+        $VISUAL_STUDIO_ROOT/Common7/Tools:\
+        $SDK/bin/x86
 
-        C:\...\> perl Configure VC-WIN32 --prefix=/OpenSSL
+        ## Microsoft SDK libs
+        LIBPATH=$WIN_VISUAL_STUDIO_ROOT\\VC\\lib\\amd64
 
-    Or for 64 bit:
+        LIB=$WIN_VISUAL_STUDIO_ROOT\\VC\\lib\\amd64\\;\
+        $WIN_KITS\\lib\\winv6.3\\um\\x64
 
-        C:\...\> perl Configure VC-WIN64A --prefix=/OpenSSL-Win64
+        INCLUDE=$WIN_VISUAL_STUDIO_ROOT\\VC\\include\\;\
+        $WIN_KITS\\include\\shared\\;$WIN_KITS\\include\\um;\
+        $WIN_KITS\\include\\winrt\\;$WIN_KITS\\include\\um\\gl
 
-    Do some setup (for 32 bit):
+        # Put nsis, c compiler and java in path
+        export PATH=$VCPATH:$PATH:$JAVA_BIN:$NSIS_BIN
 
-        C:\...\> ms\do_ms
+        # Make sure LIB and INCLUDE is available for others
+        export LIBPATH LIB INCLUDE
 
-    The same for 64 bit:
 
-        C:\...\> ms\do_win64a
+    Make sure to set the PATH so that NSIS and Microsoft SDK is found 
+    before the MSYS/Cygwin tools and that Java is last in the PATH.
 
-    Then build static libraries and install:
+    Make a simple hello world and try to compile it with the `cl` 
+    command from within bash. If that does not work, your environment 
+    needs fixing. Remember, there should be
+    no backslashes in your path environment variable in Cygwin bash,
+    but LIB and INCLUDE should contain Windows style paths with
+    semicolon, drive letters and backslashes.
 
-        C:\...\> nmake -f ms\nt.mak
-        C:\...\> nmake -f ms\nt.mak install
+*   Sun's Java JDK 1.6.0 or later. Our Java code (jinterface, ic) is
+    written for JDK 1.6.0. Get it for Windows and install it, the JRE is
+    not enough. If you don't care about Java, you can skip this step. The
+    result will be that jinterface is not built.
+
+    URL: <http://java.sun.com>
+
+    Add javac *LAST* to your path environment in bash, in my case this means:
+
+        `PATH="$PATH:/cygdrive/c/Program Files/Java/jdk1.7.0_02/bin"`
+
+    No `CLASSPATH` or anything is needed. Type `javac` in the bash prompt
+    and you should get a list of available Java options. Make sure, e.g by
+    typing `type java`, that you use the Java you installed. Note however that
+    Cygwin's/MinGW's/MSYS2's `jar.exe` is used. That's why the JDK bin-directory should be
+    added last in the `PATH`.
+
+*   Nullsoft NSIS installer system. You need this to build the self
+    installing package. It's a free open source installer that's much
+    nicer to use than the commercial Wise and Install shield
+    installers. This is the installer we use for commercial releases as
+    well.
+
+    URL: <http://nsis.sourceforge.net/download>
+
+    Install the lot, especially the modern user interface components, as
+    it's definitely needed. Put `makensis` in your path, in my case:
+
+        PATH=/cygdrive/c/Program\ Files/NSIS:$PATH
+
+    Type makensis at the bash prompt and you should get a list of options
+    if everything is OK.
+
+*   OpenSSL. This is if you want the SSL and crypto applications to
+    compile (and run). There are prebuilt binaries, which you can just 
+    download and install, available here:
+
+    URL: <http://openssl.org/community/binaries.html>
 
-    That's it - you now have your perfectly consistent static build of
-    openssl. If you want to get rid of any possibly patented
-    algorithms in the lib, just read up on the OpenSSL FAQ and follow
-    the instructions.
+    We would recommend using 1.0.2d. 
 
-    The installation locations chosen are where configure will look
-    for OpenSSL, so try to keep them as is.
-       
-*   Building with wxWidgets. Download wxWidgets-3.0.2 or higher patch
-    release.
+*   Building with wxWidgets. Download wxWidgets-3.0.2 or higher.
 
-    Install or unpack it to `DRIVE:/PATH/cygwin/opt/local/pgm`.
+    Install or unpack it to the pgm folder:
+    Cygwin: 
+        `DRIVE:/PATH/cygwin/opt/local/pgm`
+    MSYS:
+        `DRIVE:/PATH/MinGW/msys/1.0/opt/local/pgm`
+    MSYS2:
+        `DRIVE:/PATH/msys<32/64>/opt/local/pgm`
 
-    edit:  `C:\cygwin\opt\local\pgm\wxMSW-3.0.2\include\wx\msw\setup.h`
-    enable `wxUSE_POSTSCRIPT`
+    If the `wxUSE_POSTSCRIPT` isn't enabled in  `<path\to\pgm>\wxMSW-3.0.2\include\wx\msw\setup.h`,
+    enable it.
 
     build: From a command prompt with the VC tools available (See the
     instructions for OpenSSL build above for help on starting the
     proper command prompt in RELEASE mode):
 	   
-        C:\...\> cd C:\cygwin\opt\local\pgm\wxMSW-3.0.2\build\msw
+        C:\...\> cd <path\to\pgm>\wxMSW-3.0.2\build\msw
         C:\...\> nmake BUILD=release SHARED=0 DIR_SUFFIX_CPU= -f makefile.vc
     
     Or - if building a 64bit version:
 
-        C:\...\> cd C:\cygwin\opt\local\pgm\wxMSW-3.0.2\build\msw
+        C:\...\> cd <path\to\pgm>\wxMSW-3.0.2\build\msw
         C:\...\> nmake TARGET_CPU=amd64 BUILD=release SHARED=0 DIR_SUFFIX_CPU= -f makefile.vc
     	   
-*   The Erlang source distribution (from <http://www.erlang.org/download.html>).
-    The same as for Unix platforms. Preferably use tar from within Cygwin to
+*   Get the Erlang source distribution (from <http://www.erlang.org/download.html>).
+    The same as for Unix platforms. Preferably use tar from within Cygwin, MSYS or MSYS2 to
     unpack the source tar.gz (`tar zxf otp_src_%OTP-REL%.tar.gz`).
 
-    set the environment `ERL_TOP` to point to the root directory of the
+    Set the environment `ERL_TOP` to point to the root directory of the
     source distribution. Let's say I stood in `$HOME/src` and unpacked
     `otp_src_%OTP-REL%.tar.gz`, I then add the following to `.profile`:
 
         ERL_TOP=$HOME/src/otp_src_%OTP-REL%
         export $ERL_TOP
 
-*   The TCL/TK binaries. You could compile Tcl/Tk for windows yourself,
-    but you can get a stripped down version from our website which is
-    suitable to include in the final binary package. If you want to supply
-    tcl/tk yourself, read the instructions about how the tcl/tk tar file
-    used in the build is constructed under `$ERL_TOP/lib/gs/tcl`. The easy
-    way is to download <http://www.erlang.org/download/tcltk85_win32_bin.tar.gz>
-    and unpack it standing in the `$ERL_TOP` directory. This will create the
-    file `win32.tar.gz` in `$ERL_TOP/lib/gs/tcl/binaries`.
-
-    One last alternative is to create a file named `SKIP` in the
-    `$ERL_TOP/lib/gs/` after configure is run, but that will give you an
-    erlang system without gs (which might be okay as you probably will use
-    wx anyway).
-
-    Note that there is no special 64bit version of TCL/TK needed, you
-    can use the 32bit program even for a 64bit build.
 
 The Shell Environment
 ---------------------
@@ -726,37 +687,18 @@ be easy after this. You could run `./otp_build env_win32` without
 sets seems OK. The path is cleaned of spaces if possible (using DOS
 style short names instead), the variables `OVERRIDE_TARGET`, `CC`, `CXX`,
 `AR` and `RANLIB` are set to their respective wrappers and the directories
-`$ERL_TOP/erts/etc/win32/cygwin_tools/vc` and
-`$ERL_TOP/erts/etc/win32/cygwin_tool` are added first in the PATH.
-
-Try now a `type erlc`. That should result in the erlc wrapper script
-(which does not have the .sh extension, for reasons best kept
-untold...). It should reside in `$ERL_TOP/erts/etc/win32/cygwin_tools`
-or `$ERL_TOP/erts/etc/win32/msys_tools`.  You could also try `which
-cc.sh`, which `ar.sh` etc.
+`$ERL_TOP/erts/etc/win32/<cygwin/msys>_tools/vc` and
+`$ERL_TOP/erts/etc/win32/<cygwin/msys>_tool` are added first in the PATH.
 
-Now you're ready to build...
+Now you can check which erlc you have by writing `type erlc` in your shell. 
+It should reside in `$ERL_TOP/erts/etc/win32/cygwin_tools`
+or `$ERL_TOP/erts/etc/win32/msys_tools`.
 
 
 Building and Installing
 -----------------------
 
-Now it's assumed that you have executed `` eval `./otp_build env_win32` `` or 
-`` eval `./otp_build env_win32 x64` `` for this particular shell...
-
-Building is easiest using the `otp_build` script. That script takes care
-of running configure, bootstrapping etc on Windows in a simple
-way. The `otp_build` script is the utility we use ourselves to build on
-different platforms and it therefore contains code for all sorts of
-platforms. The principle is, however, that for non-Unix platforms, one
-uses `./otp_build env_<target>` to set up environment and then the
-script knows how to build on the platform "by itself". You've already
-run `./otp_build env_win32` in the step above, so now it's mostly like
-we build on any platform. OK, here are then steps; Assuming you will
-want to build a full installation executable with NSIS, you can omit
-`<installation directory>` and the release will be copied to
-`$ERL_TOP/release/win32`: and there is where the packed self installing
-executable will reside too.
+Building is easiest using the `otp_build` script: 
 
     $ ./otp_build autoconf # Ignore the warning blob about versions of autoconf
     $ ./otp_build configure <optional configure options>
@@ -764,18 +706,18 @@ executable will reside too.
     $ ./otp_build release -a <installation directory>
     $ ./otp_build installer_win32 <installation directory> # optional
 
-Now you will have a file called `otp_win32_R12B.exe` in the
-`<installation directory>`, i.e. `$ERL_TOP/release/win32`.
+Now you will have a file called `otp_win32_%OTP-REL%.exe` or `otp_win64_%OTP-REL%.exe` 
+in the `<installation directory>`, i.e. `$ERL_TOP/release/win32`.
 
 Lets get into more detail:
 
 1.  `$ ./otp_build autoconf` - This step rebuilds the configure scripts
-    to work correctly in the cygwin environment. In an ideal world, this
+    to work correctly in your environment. In an ideal world, this
     would not be needed, but alas, we have encountered several
     incompatibilities between our distributed configure scripts (generated
-    on a Linux platform) and the cygwin environment over the
-    years. Running autoconf on cygwin ensures that the configure scripts
-    are generated in a cygwin-compatible way and that they will work well
+    on a Linux platform) and the Cygwin/MSYS/MSYS2 environment over the
+    years. Running autoconf in Cygwin/MSYS/MSYS2 ensures that the configure 
+    scripts are generated in a compatible way and that they will work well
     in the next step.
 
 2.  `$ ./otp_build configure` - This runs the newly generated configure
@@ -784,38 +726,21 @@ Lets get into more detail:
     this awkward target name and behave accordingly. The CC variable also
     makes the compiler be `cc.sh`, which wraps MSVC++, so all configure
     tests regarding the C compiler gets to run the right compiler. A lot of
-    the tests are not needed on Windows, but I thought it best to run the
-    whole configure anyway. The only configure option you might want to
-    supply is `--with-ssl`, which might be needed if you have built your
-    own OpenSSL distribution. The Shining Lights distribution should be
-    found automatically by `configure`, if that fails, add a
-    `--with-ssl=<dir>` that specifies the root directory of your OpenSSL
-    installation.
+    the tests are not needed on Windows, but we thought it best to run the
+    whole configure anyway.
 
 3.  `$ ./otp_build boot -a` - This uses the bootstrap directory (shipped
     with the source, `$ERL_TOP/bootstrap`) to build a complete OTP
-    system. It first builds an emulator and sets up a minimal OTP system
-    under `$ERL_TOP/bootstrap`, then starts to compile the different OTP
-    compilers to make the `$ERL_TOP/bootstrap` system potent enough to be
-    able to compile all Erlang code in OTP. Then, all Erlang and C code
-    under `$ERL_TOP/lib` is built using the bootstrap system, giving a
-    complete OTP system (although not installed). When this is done, one
-    can run Erlang from within the source tree, just type `$ERL_TOP/bin/erl`
-    and you should have a prompt. If you omit the -a flag, you'll get a
-    smaller system, that might be useful during development. Now
-    exit from Erlang and start making a release of the thing:
+    system. When this is done you can run erl from within the source tree; 
+    just type `$ERL_TOP/bin/erl` and you whould have the prompt. 
 
 4.  `$ ./otp_build release -a` - Builds a commercial release tree from the
-    source tree, default is to put it in `$ERL_TOP/release/win32`, you can
+    source tree. The default is to put it in `$ERL_TOP/release/win32`. You can
     give any directory as parameter (Cygwin style), but it doesn't really
-    matter if you're going to build a self extracting installer too. You
-    could of course build release to the final directory and then run
-    `./Install.exe` standing in the directory where the release was put,
-    that will create a fully functional OTP installation. But let's make
-    the nifty installer:
-
-5.  `$ ./otp_build installer_win32` - Create the self extracting installer
-    executable. The executable `otp_win32_%OTP-REL%.exe` will be placed
+    matter if you're going to build a self extracting installer too. 
+
+5.  `$ ./otp_build installer_win32` - Creates the self extracting installer executable. 
+    The executable `otp_win32_%OTP-REL%.exe` or `otp_win64_%OTP-REL%.exe` will be placed
     in the top directory of the release created in the previous step. If
     no release directory is specified, the release is expected to have
     been built to `$ERL_TOP/release/win32`, which also will be the place
@@ -824,7 +749,7 @@ Lets get into more detail:
     /tmp/erl_release`), you're expected to give the same parameter here,
     (i.e. `./otp_build installer_win32 /tmp/erl_release`). You need to have
     a full NSIS installation and `makensis.exe` in your path for this to
-    work of course. Once you have created the installer, you can run it to
+    work. Once you have created the installer, you can run it to
     install Erlang/OTP in the regular way, just run the executable and
     follow the steps in the installation wizard. To get all default settings
     in the installation without any questions asked, you run the executable
@@ -844,37 +769,17 @@ Lets get into more detail:
     and after a while Erlang/OTP-%OTP-REL% will have been installed in
     `C:\Program Files\erl%ERTS-VSN%\`, with shortcuts in the menu etc.
 
-    The necessary setup of an Erlang installation is actually done by the
-    program `Install.exe`, which resides in the release top. That program
-    creates `.ini`-files and copies the correct boot scripts. If one has
-    the correct directory tree (like after a `./otp_build release -a`), only
-    the running of `Install.exe` is necessary to get a fully functional
-    OTP. What the self extracting installer adds is (of course) the
-    possibility to distribute the binary easily, together with adding
-    shortcuts to the Windows start menu. There is also some adding of
-    entries in the registry, to associate `.erl` and `.beam` files with
-    Erlang and get nifty icons, but that's not something you'll really need
-    to run Erlang. The registry is also used to store uninstall information,
-    but if one has not used the self extracting installer, one cannot
-    (need not) do any uninstall, one just scratches the release directory
-    and everything is gone. Erlang/OTP does not *need* to put anything
-    in the Windows registry at all, and does not if you don't use the self
-    extracting installer. In other words the installer is pure cosmetics.
-
-> *NOTE*: Beginning with R9C, the Windows installer does *not* add Erlang
-> to the system wide path. If one wants to have Erlang in the path, one
-> has to add it by hand.
 
 Development
 -----------
 
 Once the system is built, you might want to change it. Having a test
-release in some nice directory might be useful, but you also can run
+release in some nice directory might be useful, but you can also run
 Erlang from within the source tree. The target `local_setup`, makes
 the program `$ERL_TOP/bin/erl.exe` usable and it also uses all the OTP
 libraries in the source tree.
 
-If you hack the emulator, you can then build the emulator executable
+If you hack the emulator, you can build the emulator executable
 by standing in `$ERL_TOP/erts/emulator` and do a simple
 
     $ make opt
@@ -923,12 +828,12 @@ or even in the source directory...
     $ cd $ERL_TOP/lib/stdlib/src
     $ make opt
 
-Note that you're expected o have a fresh Erlang in your path when
+Note that you're expected to have a fresh Erlang in your path when
 doing this, preferably the plain %OTP-REL% you have built in the previous
 steps. You could also add `$ERL_TOP/bootstrap/bin` to your `PATH` before
-rebuilding specific libraries, that would give you a good enough
+rebuilding specific libraries. That would give you a good enough
 Erlang system to compile any OTP erlang code.  Setting up the path
-correctly is a little bit tricky, you still need to have
+correctly is a little bit tricky. You still need to have
 `$ERL_TOP/erts/etc/win32/cygwin_tools/vc` and
 `$ERL_TOP/erts/etc/win32/cygwin_tools` *before* the actual emulator
 in the path. A typical setting of the path for using the bootstrap
@@ -963,57 +868,27 @@ Remember that:
 
 That's basically all you need to get going.
 
+
 Using GIT
 ---------
 
-You might want to check out versions of the source code from GitHUB. That is possible directly in cygwin, but not in Msys. There is a project MsysGIT:
+You might want to check out versions of the source code from GitHUB. That is possible directly in Cygwin, but not in MSYS. There is a project MsysGIT:
 
 URL:<http://code.google.com/p/msysgit/>
 
 that makes a nice Git port. The msys prompt you get from MsysGIT is
 however not compatible with the full version from MinGW, so you will
 need to check out files using MsysGIT's command prompt and then switch
-to a common Msys command prompt for building. Also all test suites
-cannot be built as MsysGIT/Msys does not handle symbolic links. To
-build test suites on Windows, you will need Cygwin for now. Hopefully
-all symbolic links will disappear from our repository soon and this
-issue will disappear.
+to a common MSYS command prompt for building. Also all test suites
+cannot be built as MsysGIT/MSYS does not handle symbolic links. 
 
-Final Words
------------
-My hope is that the possibility to build the whole system on Windows
-will open up for free development on this platform too. There are many
-things one might want to do better in the Windows version, like the
-window-style command prompt as well as pure Cygwin porting. Although i
-realize it's a much larger step to start building on Windows (with all
-the software you need) than for instance on Linux, I sincerely hope
-that some of you will make the effort and start submitting Windows
-friendly patches.
-
-The first build system for Erlang using Cygwin on Windows was created
-by Per Bergkvist. I haven't used his build system, but it's rumored to
-be good. The idea to do this came from his work, so credit is well
-deserved.
-
-Of course this would have been completely impossible without the
-excellent Cygwin. The guys at Cygnus solutions and
-Redhat deserve a huge THANKS! as well as all the other people in the
-free software community who have helped in creating the magnificent
-software that constitutes Cygwin.
-
-Also the people developing the alternative command prompt Msys and
-the MinGW compiler are worth huge THANKS! The 64bit port would have
-been impossible without the 64bit MinGW compiler.
-
-Good luck and Happy Hacking,
-Patrik, OTP
 
 Copyright and License
 ---------------------
 
 %CopyrightBegin%
 
-Copyright Ericsson AB 2003-2014. All Rights Reserved.
+Copyright Ericsson AB 2003-2015. All Rights Reserved.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -1030,6 +905,8 @@ limitations under the License.
 %CopyrightEnd%
 
 
-   [1]: http://www.erlang.org/faq.html "mailing lists"
+   [1]: http://www.erlang.org/static/doc/mailinglist.html
+   [2]: http://bugs.erlang.org
+   [3]: https://github.com/erlang/otp
 
    [?TOC]: true