Pidgin for Windows Build Instructions

Note: These instructions are for 3.0.0 branch. The current instructions for 2.x.y are found here.

Get the Pidgin source code

The 3.0.0 branch isn't released yet, so there are no source packages for this at the moment.

The development source is available via mercurial. See UsingPidginMercurial for more information.

Cross Compiling (the easy way)

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 mingw-w64 and mingw-w64-tools. On other distributions, the packages may be named differently.

Next, you need to set up a MinGW development directory and populate it with all of the Pidgin dependencies. Start by defining that in an environment variable. The exact location can be changed to fit your filesystem:

export WIN_DEV_DIR=${HOME}/win-dev/

Fetch the dependencies using the ​bootstrap script:

wget -nv -P"$WIN_DEV_DIR" "https://bitbucket.org/%21api/2.0/snippets/CMaiku/pon5L/files/pidgin-bootstrap.sh"
chmod +x "${WIN_DEV_DIR}/pidgin-bootstrap.sh"
${WIN_DEV_DIR}/pidgin-bootstrap.sh

Create a cross compile file for meson. It should be named win32_cross.txt for following this guide. Details can be found ​here, and an example you can edit to your system is ​here. It's important to include these lines in the properties section:

[properties]
c_args = ['-I/path/to/win-dev-dir/mingw32/include/']
c_link_args = ['-static-libgcc']

Edit the c_args line to point to the full path of ${WIN_DEV_DIR}/mingw32/include/. The c_link_args line is unnecessary for 64-bit.

Set up pkg-config:

export PKG_CONFIG_SYSROOT_DIR=${WIN_DEV_DIR}
export PKG_CONFIG_PATH="${WIN_DEV_DIR}/mingw32/lib/pkgconfig"

Create your build directory with the --cross-file option. Make sure to have the Pidgin source tree as a child of the current directory.

meson pidgin build-win32 --cross-file win32_cross.txt --prefix=/mingw32/ -Dconsoleui=false -Dvv=false -Dintrospection=false -Dlibdir=lib

Change into the build directory and build it:

cd build-win32
ninja

And last, install Pidgin and its dependencies. It can be installed anywhere, but it needs dependencies which are, according to this guide, already in ${WIN_DEV_DIR}/mingw32. So for simplicity, this guide installs them there.

DESTDIR=${WIN_DEV_DIR} ninja install

Now you're done. ${WIN_DEV_DIR}/mingw32/ can be copied to a Windows machine and run as is (${WIN_DEV_DIR}/mingw32/bin/pidgin.exe). However, see below regarding TLS certificates.

TLS Certificates

Pidgin 3 uses Gio for its TLS certificates, which by default uses Certificate Authorities from ${WIN_DEV_DIR}/ssl/certs/ca-bundle.crt. Because of the way the dependencies are fetched, currently this file is empty. There are three methods to resolve this:

Populate the file by running p11-kit from the cross compiling host:

p11-kit extract --format=pem-bundle --filter=ca-anchors --overwrite --purpose server-auth ${WIN_DEV_DIR}/ssl/certs/ca-bundle.crt

OR run it from Windows (run from ${WIN_DEV_DIR}):

bin\p11-kit.exe extract --format=pem-bundle --filter=ca-anchors --overwrite --purpose server-auth ssl\certs\ca-bundle.crt

OR bypass the file and use the alternate Gio TLS Backend by setting the environment variable:

set GIO_USE_TLS=gnutls-pkcs11

Compiling directly on Windows with MSYS2 (the also easy way)

Download MSYS2 from ​https://www.msys2.org/. Pick whichever download is appropriate for your platform. Follow the install instructions on that page. If it asks about removing libcatgets, respond with y.

Install mingw-w64-i686-toolchain, or mingw-w64-x86_64-toolchain for building 64-bit Pidgin:

pacman -S mingw-w64-i686-toolchain

Fetch the PKGBUILD file:

wget -q 'https://bitbucket.org/!api/2.0/snippets/CMaiku/Ae7oAA/files/PKGBUILD'

Build the package. Use MINGW_INSTALLS=mingw64 for 64-bit, or omit the environment variable to build both. You'll need both toolchains above to build both:

MINGW_INSTALLS=mingw32 makepkg-mingw -sCLf

Follow the prompts. Respond with y for installing dependencies.

Install the newly built Pidgin package:

pacman -U mingw-w64-i686-pidgin-hg-*.pkg.tar.xz

Run Pidgin with either pidgin in the MSYS2 shell, or find it in the MSYS2 install directory under mingw32/bin/pidgin.exe, or mingw64/bin/pidgin.exe for 64-bit, outside of MSYS2.

Note: You can add the --noconfirm flag to the pacman and makepkg-mingw commands to skip prompting for installing dependencies etc.

Warning: As of this writing, the 64-bit build doesn't display text in chat windows and therefore isn't very useful. It's best to stick with 32-bit builds until that's resolved.

Compiling directly on Windows with Cygwin (the hard way)

This method was used for 2.x.y branch and most probably will be dropped, when cross-compilation was fully functional (including the installer).

Set up your build environment

1. Install the ​Cygwin Bash shell. Make sure to select Unix file mode during setup. Also make sure you install bash, bzip2, ca-certificates, coreutils, gawk, gnupg, grep, gzip, libiconv, make, mercurial, patch, sed, tar, unzip, wget, xxd and zip (several of these are selected by default, those in bold are not). Be sure to add Cygwin versions of any programs you may use that require Cygwin path names (for example, if you want to use vim to edit commit messages, you need to install the Cygwin version of vim -- native Win32 vim will be unable to read Cygwin-style paths).
   You may prefer to use ​MSYS instead of Cygwin.

2. Download and install ​NSIS and its plugins:
   • extract SHA1Plugin.dll from pidgin-inst-deps-20130214.tar.gz into the Plugins directory of your NSIS installation;
   • download the ​nsisunz plugin, and extract nsisunz.dll into the Plugins directory, like above.

3. Download Perl 5.20 or newer and install it, preferably to C:\Perl. You may use ​Strawberry Perl.

4. Extract or check out the Pidgin source into $PIDGIN_DEV_ROOT/pidgin-<version>. Some users may find the instructions for customizing their build environment useful.

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.

People are sometimes confused about the directory structure, so here is an example structure after all the dependencies have been installed ($PIDGIN_DEV_ROOT is c:\devel\pidgin-devel in this example):

c:\devel\pidgin-devel
(The following is the source tree root, containing config.h.mingw.)
c:\devel\pidgin-devel\pidgin-<version>
(If the following file is present, your structure is probably correct.)
c:\devel\pidgin-devel\pidgin-<version>\pidgin\win32\prepare-workspace.sh

5. Go through the rest of setting build environment using automatic setup script by running the following from Cygwin terminal:

   cd $PIDGIN_DEV_ROOT/pidgin-<version>/pidgin/win32
   ./prepare-workspace.sh
   

Build Pidgin

Run 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.

Build the Pidgin Installer

If you want to sign the executables (not necessary for personal use), you'll need to get an appropriate code signing certificate, generate a GPG key if you don't already have one, then download and install ​Mono. In your local.mak file (see below), define the SIGN_EXECUTABLES variable to 1, MONO_SIGNCODE to the fully qualified path to the signcode batch file in the Mono bin directory, and the SIGNCODE_SPC and SIGNCODE_PVK variables to the appropriate files from your certificate. E.g.:

SIGN_EXECUTABLES=1
MONO_SIGNCODE=/cygdrive/c/Program\ Files\ \(x86\)/Mono-2.10.8/bin/signcode
SIGNCODE_SPC=c:\\Path\\to\\authenticode.spc
SIGNCODE_PVK=c:\\Path\\to\\authenticode.pvk
#Set up gpg to use a separate keyring
GPG_SIGN=gpg --no-default-keyring --secret-keyring /path/to/secring.gpg

If you don't need executable signing, you can start here.

There are 2 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. To build both, use 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>/.

Customizing the Build Environment

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 flags.

This done is 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.

Most of the variables that can be overridden with this method are defined in the ​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.

Debugging

There is a quite good Just In Time debugger for MinGW: ​drmingw.
There is also a version of gdb available from MinGW, if you prefer.