Update the links for the groupme protocol to the active repository

Testing Done:
Ran the devserver and verified everything looked okay.

Reviewed at
title: Windows
date: 2019-09-04T02:46:13.000Z
lastmod: 2019-09-17T02:47:39.000Z
Note: These instructions are kept current for the development version of
`release-2.x.y` branch of Pidgin. You may need to look at an older version of
this page in order to build a released version of Pidgin. Alternatively, you
may need the instructions for 3.0.0 branch.
## Set up your build environment
### Install A Bash Shell
The Pidgin build system requires a full Unix shell to run. You can install
[Cygwin]( or [MSYS2]( to accomplish
this. However, these instructions are heavily geared towards Cygwin so MSYS
steps may be different and/or missing all together.
Alternatively, you may use the third-party script
[Pidgin Windev](, which
creates the development environment automatically. This tool works for
both Cygwin and MSYS2.
#### Cygwin
When installing [Cygwin]( you will be asked which additional
packages you would like to install. You need to make sure that the following
packages are installed. Some of these are selected by default, but the ones in
bold are not installed by default.
* bash
* bzip2
* **ca-certificates**
* coreutils
* gawk
* **gnupg**
* grep
* gzip
* **libiconv**
* **make**
* **patch**
* sed
* tar
* **unzip**
* **wget**
* **zip**
#### MSYS2
After installing [MSYS2](, you'll need to make sure that
you have all the base dependencies installed as well. You can do that with the
following command:
$ pacman -Sy ca-certificates gawk grep make patch tar unzip wget zip
### Setup
The following instructions were written under the assumption that the
[Pidgin source]({{< ref "#get-the-pidgin-source-code" >}}) will be extracted or checked out
into `$PIDGIN_DEV_ROOT/pidgin-<version>` and that you install all of Pidgin's
build dependencies under `$PIDGIN_DEV_ROOT/win32-dev` (the point being that
the pidgin source root and `win32-dev` directories should be on the same level). Similar to the example below:
├── pidgin-2.x.y
└── win32-dev
You don't have to actually define an environment variable called
`PIDGIN_DEV_ROOT`, it is simply used here as a placeholder.
**Note** You should avoid using a `$PIDGIN_DEV_ROOT` path that contains
spaces as that can cause unnecessary complications.
#### Customizing
Most people will find that the standard build environment directory is
completely adequate. It is, however, possible to override the locations of the
various dependencies and target directories. This is often useful to test
against a development version of a library dependency or to override compiler
This is done by overriding the various Makefile variables in a `local.mak`
file in the `$PIDGIN_DEV_ROOT/pidgin-<version>` directory. This file does not
exist by default.
The variables that can be overridden with this method are defined in the
[libpurple/win32/global.mak](https://{{< repo pidgin >}}src/release-2.x.y/libpurple/win32/global.mak)
file. For example, to install Pidgin over `c:\Program Files\Pidgin` instead
of `$PIDGIN_DEV_ROOT/pidgin/win32-install-dir`, create a
`$PIDGIN_DEV_ROOT/pidgin/local.mak` containing:
#Override the install location
PIDGIN_INSTALL_DIR = /cygdrive/c/Program\ Files/Pidgin
PURPLE_INSTALL_DIR = /cygdrive/c/Program\ Files/Pidgin
One nice use of the `local.mak` file is for cross compiling, there is an
additional example in the [#cross-compiling section below].
## Get the Pidgin source code
The development source is available via Mercurial in the `release-2.x.y`
If you want to build a release tarball, the instructions in the rest of this
document should work for you, however they are written for the most recent
2.x.y release so there may be issues with older versions.
## Build Dependencies
### Compiler
Installing all of the build dependencies can be tedious, so you may want to
check out [Pidgin Windev]( which
will automate it.
Install the MinGW "GCC Version 4.7.2" packages from the
[MinGW site]( by following
[their instructions](
Download the following:
* [binutils-2.24](
* mingw-runtime-3.20 ([dev]( and [dll](
* [w32api-3.17](
* Required runtime libraries for GCC:
* mpc-0.8.1-1 ([dev]( and [dll](
* mpfr-2.4.1-1 ([dev]( and [dll](
* gmp-5.0.1-1 ([dev]( and [dll](
* pthreads-2.9.0-pre-20110507-2 ([dev]( and [dll](
* iconv ([dev]( and [dll](
* [intl-](
* [gomp-4.7.2-1](
* [ssp-4.7.2-1](
* [quadmath-4.7.2-1](
* gcc-core-4.7.2-1 ([bin]( and dev and [dll](
* [gcc-4.7.2-1-mingw32-src](
* so we can distribute the libssp source since we distribute the binary
Extract all of the above into the desired location (e.g.
Prepare a `libssp-src.tar.gz` file containing the libssp sources and licenses:
cd $PIDGIN_DEV_ROOT/win32-dev/mingw-4.7.2
mkdir libsspsrctmp
tar -C libsspsrctmp -xf gcc-4.7.2-1-mingw32-src/gcc-4.7.2.tar.bz2 gcc-4.7.2/COPYING3 gcc-4.7.2/COPYING.RUNTIME gcc-4.7.2/libssp --strip-components=1
tar -C libsspsrctmp -czf bin/libssp-src.tar.gz .
rm -r libsspsrctmp
Finally, set the MinGW gcc's bin directory to be before Cygwin's in your
For example (You should add the following to your `~/.bashrc` file, which is
found in `C:\cygwin\home\YourUsername\` by default):
export PATH=/cygdrive/c/devel/pidgin-devel/win32-dev/mingw-4.7.2/bin:$PATH
### Installing
#### GTK
Pidgin depends on GTK 2.14.7 (newer runtime versions can be used). The GTK
All-in-one bundle contains all of GTK's dependencies in one zip file. Download
and extract to `$PIDGIN_DEV_ROOT/win32-dev/gtk_2_0-2.14` (you'll need to create
this directory).
Visit the [GTK website]( for official
binary and source releases.
#### gettext
You'll need gettext to compile translations. Download
Extract both to `$PIDGIN_DEV_ROOT/win32-dev/gettext-0.17` (you'll need to
create this directory).
#### Libxml2
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
#### Perl 5.20
You'll need a functioning perl 5.20.x runtime (if the perl executable isn't in
your `PATH`, you will need to override the `PERL` variable in
`pidgin/local.mak` to point to the appropriate perl executable). A good option
is [Strawberry Perl](
Download the
development package and extract to `$PIDGIN_DEV_ROOT/win32-dev` (it creates its
own directory). This is a subset of the full 32-bit strawberry perl zip
containing just the headers, import lib, and source for perl.
**Note** If using MSYS and you installed the `mingw-developer-toolkit`, keep
in mind that it installs `msys-perl-bin` (Perl 5.6) which takes precedence
over the newer perl in your path, and that will cause problems! The easiest
solution is to set the `PERL` variable in your `pidgin/local.mak` to point to
the right perl.exe.
#### GtkSpell
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
#### Enchant
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev/`.
#### Mozilla NSS
Download and extract
under `$PIDGIN_DEV_ROOT/win32-dev`.
**NOTE** NSS/NSPR are built from the upstream sources using
[these instructions](buildings-win-nss/).
#### SILC Toolkit
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
#### Meanwhile
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
#### Cyrus SASL
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
#### Intltool
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev/intltool_0.40.4-1_win32`.
#### Crash Reporting Library
Download and extract
to `$PIDGIN_DEV_ROOT/win32-dev`.
## Build
### Building Pidgin
The Windows build will take a while, but you can start it with the following
cd $PIDGIN_DEV_ROOT/pidgin-<version>
make -f Makefile.mingw install
Now just wait and let your compiler do its thing. When finished, Pidgin will
be in `$PIDGIN_DEV_ROOT/pidgin-<version>/win32-install-dir`.
### Building the Installer
If you would like to build the Pidgin installer, you'll need to setup
[NSIS]( Once you have installed
NSIS, please make sure that it is in your shell's `PATH`. Note if you're
building with msys2 do not use the version available in pacman. There are
multiple issues with it including that executables produced by it will not be
able to run if Mandatory ASLR is enabled.
Next you'll need to download a few plugins and put them into the
`Plugins/x86-unicode` folder of your NSIS install.
* [nsis unzip plugin](
* [nsis inetc plugin](
* [nsis crypto plugin](
Finally, you'll need to decide if you would like to sign the executables though
this is not necessary for personal use.
To sign the executables, you need to get an appropriate code signing
certificate and then install
[osslsigncode]( If you're using
msys2 this can be installed with `pacman -S mingw-w64-i686-osslsigncode`.
In your `local.mak` file (see [customizing](#customizing) above), define the
`OSSLSIGNCODE` variable to the fully qualified path to the `signcode`
executable. You'll also need to assign the `SIGNCODE_SPC` and
`SIGNCODE_PVK` variables to the appropriate files in your certificate. If you
just have a `pfx` file, you'll need to extract the certificate and key to the
`spc` and `pvk` files. You can find documentation to do so
Also, you'll need a PGP key to add pgp signatures to the files. GnuPG is the
primary PGP client most people use. You can read more
Once you have everything setup your `local.mak` should look something like the
#Set up gpg to use a separate keyring
GPG_SIGN=gpg --no-default-keyring --secret-keyring /path/to/secring.gpg
If you aren't going to be signing anything, your `local.mak` should look like
the following:
#Disable Signing
OSSLSIGNCODE=echo ***Bypassing signcode***
GPG_SIGN=echo ***Bypassing gpg***
At this point, you can finally build the installer. However, there are
actually two different installers; an "Offline" installer that includes all
dependencies (except spellchecking dictionaries) and the debug symbols and an
"Online" installer that includes only Pidgin itself and will download the
various dependencies if necessary.
The `Makefile.mingw` targets for these are `installer_offline` and `installer`
respectively. You can build both with the `installers` target.
cd $PIDGIN_DEV_ROOT/pidgin-<version>
make -f Makefile.mingw installers
When it finishes, your installer(s) should be in
`$PIDGIN_DEV_ROOT/pidgin-<version>/` directory.
## Debugging
There is a quite good **Just In Time** debugger for MinGW named
[drmingw]( You can download it from
their [releases](
There is also a version of `gdb` available from MinGW, if you prefer.
## Cross Compiling
It is quite easy to cross compile Pidgin for Windows on a Linux machine.
To begin, you'll need to install MinGW. On Debian/Ubuntu, this involves
installing packages `mingw32`, `mingw32-binutils`, and `mingw32-runtime`. On
other distributions, the packages may be named differently.
Set up a build environment as described
[above]({{< ref "#set-up-your-build-environment" >}}).
You should already have a bash shell and have just installed the mingw
Create a `local.mak` file in the source directory root to override the
Makefile variables, something like the following:
SHELL := /bin/bash
CC := /usr/bin/i586-mingw32msvc-cc
GMSGFMT := msgfmt
MAKENSIS := /usr/bin/makensis
WINDRES := /usr/bin/i586-mingw32msvc-windres
STRIP := /usr/bin/i586-mingw32msvc-strip
INTLTOOL_MERGE := /usr/bin/intltool-merge
INCLUDE_PATHS := -I$(PIDGIN_TREE_TOP)/../win32-dev/w32api/include
LIB_PATHS := -L$(PIDGIN_TREE_TOP)/../win32-dev/w32api/lib
If your distribution doesn't include a recent enough win32api, you can
download it from the [MinGW site](, extract it into
your `win32-dev` directory, and override the `INCLUDE_PATHS` and `LIB_PATHS`
variables in your `local.mak` as shown above.
NSIS version 2.46 or greater is required to cross-compile. If compiling NSIS
from source, the [scons]( package is a dependency.
This can usually be installed through your linux distribution's package
archive. An example of how to install the NSIS package is given below
(Assuming use of the NSIS 2.46 version).
mkdir nsis; cd nsis
tar -jxvf nsis-2.46-src.tar.bz2
cd nsis-2.46
sudo scons install-compiler
cd ..
sudo unzip nsis-2.46 -d /usr/local/share
sudo mv /usr/local/share/nsis-2.46/ /usr/local/share/nsis
Once this is done, you'll need to update `local.mak` to point to the new NSIS
MAKENSIS := /usr/local/bin/makensis
Finally, you should be able to follow the
[build]({{< ref "#build" >}}) instructions