FFTW Logo
Go back to the FFTW download page.

Windows Installation Notes

This document contains various information regarding installation of FFTW on DOS/Windows. (It was sent in by users, and has not been personally verified by us.) Please contact us if you have any additions or corrections. You should, of course, first read the Installation on non-Unix Systems of the FFTW 3 manual (or the corresponding section of the FFTW 2 manual).

Precompiled FFTW 3.3.4 Windows DLLs

We have created precompiled DLL files for FFTW 3.3.4 in single/double/long-double precision, along with the associated test programs. We hope that these are sufficient for most users, so that you need not worry about compiling FFTW:

These DLLs were created by us, cross-compiled from GNU/Linux using MinGW; the 64-bit version is possible thanks to the mingw-w64 project. You should be able to call them from any compiler. In order to link to them from Visual C++, you will need to create .lib "import libraries" using the lib.exe program included with VC++. Run:

     lib /def:libfftw3-3.def
     lib /def:libfftw3f-3.def
     lib /def:libfftw3l-3.def

On Visual Studio 2008 in 64-bit mode, and possibly in other cases, you may need to specify the machine explicitly:

     lib /machine:x64 /def:libfftw3l-3.def

For Borland C++, you instead need to use Borland's implib program, via (thanks to M. Lenarczyk):

     implib -a fftw3-3.lib libfftw3-3.dll
     implib -a fftw3f-3.lib libfftw3f-3.dll
     implib -a fftw3l-3.lib libfftw3l-3.dll

See DLLs and wisdom, below, for important information on using wisdom import/export from a DLL.

Contact us if you have suggestions, but realize that we don't use Windows ourselves.

We created these .zip files with the scripts BUILD-MINGW32.sh and BUILD-MINGW64.sh; see also the MinGW instructions below. Thanks to John Pavel for his extensive feedback.

Compiling FFTW 3 for Windows

If for some reason you need to compile FFTW yourself on Windows, rather than using the above DLLs, you have several options:

If you do compile FFTW yourself, we encourage you to compare the speed of the resulting executable with the gcc-compiled version that we provide above. In particular, you can use the bench.exe program to benchmark a few typical sizes to get an idea of how they compare:

     bench.exe -opatient 64 128 256 512 1024 2048 4096

Building FFTW 3 under MinGW

The simplest way to compile FFTW on Windows is probably to install the free MinGW Unix environment so that you can use the GNU C compiler (gcc).

There are a few options to our configure script that we especially recommend on Windows:

So, for example, to build a double-precision library you might use

    ./configure --with-our-malloc16 --with-windows-f77-mangling --enable-shared --disable-static --enable-threads --with-combined-threads --enable-portable-binary --enable-sse2 --with-incoming-stack-boundary=2
    make
    make install

The resulting DLL files are installed in /usr/local/bin.

Important: If you want to call the resulting DLL from another compiler (i.e. not from MinGW), you need to add a line #define FFTW_DLL to fftw3.h (installed in /usr/local/include). This adds some __declspec decorations to the function declarations.

Building FFTW 3.x under Visual C++/Intel compilers

Important: If you want to compile FFTW as a DLL, you should add a line #define FFTW_DLL to fftw3.h and ifftw.h before compiling. This will add the requisite __declspec decorations to function declarations etc.

Project files to compile FFTW 3.3 with Visual Studio 2010 were sent to us by Long To: fftw-3.3-libs-visual-studio-2010.zip.

Project files to compile FFTW 3.2.2 with Visual Studio 2010 were sent to us by Long To: fftw-3.2.2-libs-visual-studio-2010.zip.

Project files to compile FFTW 3.2.2 with Visual Studio 2008 were sent to us by Nathaniel Meyer (nate at nutty dot ca): fftw-3.2.2-vs2008.zip.

Project files to compile FFTW 3.1.2 with the Intel compilers under Visual Studio .NET 2003 were sent to us by Jin Tian (jintian at nlsde dot buaa dot edu dot cn): fftw-3.1.2-vs2003.zip.

Franz Franchetti has graciously offered to provide up-to-date FFTW binaries and project files using Visual Studio and the Intel C compiler at his web page.

DLLs and wisdom

FFTW implements a mechanism called "wisdom" for saving plans to disk (see the manual). FFTW 3.3 includes fftw_export_wisdom_to_filename and fftw_import_wisdom_from_filename functions where you supply a filename to write/read to/from, respectively. We believe that these should work fine from Windows DLLs.

However, FFTW also provides fftw_export_wisdom_to_file and fftw_import_wisdom_from_file routines where you specify a C FILE pointer to a file you have opened yourself, and users have reported that these routines do not work properly from DLLs. (These were the only file I/O routines in versions of FFTW prior to 3.3.) It's been suggested to us that this has to do with there being multiple C runtime libraries in Windows (see here).

We expect that most users will need only the filename functions. However, if you need to use the fftw_export_wisdom_to_file and fftw_import_wisdom_from_file functions (e.g. you need to write wisdom to part of a file, and write something else to the rest of the file), then you can use the following workaround in Windows. In particular, FFTW provides generic import/export functions that allow you to specify a routine for reading/writing characters. That way, you can supply a routine to access the file yourself and the DLL never has to see it. You can provide a drop-in replacement for FFTW's fftw_export_wisdom_to_file and fftw_import_wisdom_from_file functions simply by including the following lines after you #include <fftw3.h>:

static void my_fftw_write_char(char c, void *f) { fputc(c, (FILE *) f); }
#define fftw_export_wisdom_to_file(f) fftw_export_wisdom(my_fftw_write_char, (void*) (f))
#define fftwf_export_wisdom_to_file(f) fftwf_export_wisdom(my_fftw_write_char, (void*) (f))
#define fftwl_export_wisdom_to_file(f) fftwl_export_wisdom(my_fftw_write_char, (void*) (f))

static int my_fftw_read_char(void *f) { return fgetc((FILE *) f); }
#define fftw_import_wisdom_from_file(f) fftw_import_wisdom(my_fftw_read_char, (void*) (f))
#define fftwf_import_wisdom_from_file(f) fftwf_import_wisdom(my_fftw_read_char, (void*) (f))
#define fftwl_import_wisdom_from_file(f) fftwl_import_wisdom(my_fftw_read_char, (void*) (f))

Older stuff

Below are older instructions and packages that were sent to us, but which are now probably out of date.

FFTW 3.0.1 and Visual C++/Intel compilers

Alessio Massaro contributed Windows binaries of fftw-3.0.1, compiled with the Intel C Compiler version 7.1. This package uses SSE/SSE2 instructions when appropriate. This archive is called fftw-3.0.1-w32-pl1.zip and was created on Nov 13, 2003. If you downloaded the older archive fftw-3.0.1-w32.zip, please upgrade. Some library symbols were incorrectly not exported in the older build.

Alessio has also sent us Windows binaries compiled with gcc under MinGW, which support for threads and have AMD K7 (3dNow!) in addition to SSE/SSE2. An updated version of this file was contributed by Boran Car, which incorporates a missing libgcc.a library file. This library can be called from Visual C++ and other Windows compilers.

Klaus Maisinger contributed .def and .lib files for Borland C++ Builder 6 to to allow you to use the above Intel-compiled binaries; you need to use Klaus' fftw3.lib in addition to fix compatibility problems between Borland C++ and Visual C++. See also his description of what he did.

The above binaries were, unfortunately, compiled without the Fortran wrapper routines. Koos Huijssen sent us a library file for Compaq Visual Fortran that you can use, in addition to Alessio's DLL, to call FFTW from that Fortran compiler.

Stephane Ruel helped us to get FFTW 3 working under Visual C++, and sent us a build file to compile FFTW with that compiler. (Note that this package provides modified versions of some FFTW files, which are no longer necessary with FFTW version 3.0.1. Also, it refers to the files rdft/vrank2-transpose.c and rdft/vrank3-transpose.c, which are no longer included or needed; references to them should be deleted from the build, or you can create empty files with these names. Other compiler warnings can be ignored.)

Mark Roden send us modified build files to use Visual C++ 6.0 with version 8.0 of the Intel compiler and FFTW 3.0.1, with threads and SSE enabled.

Visual C++ Problems

Visual C++ is buggy. Get a real compiler and do not complain to us.

Stephane Ruel was unable to get the SIMD (SSE) code to produce correct results with Visual C++ 6.0; we suspect a compiler bug (the same code works fine with gcc and Intel icc). We have an unconfirmed report of similar problems with version 7.0. If you have a more recent version of VC++, please let us know whether it works.

Stephane recently reported that he was able to compile the SIMD code in FFTW 3.0.1 using the Intel compiler version 7.1 (with flags -O3 -G7 -QxW) with Visual C++. (Modify config.h to #define either HAVE_SSE or HAVE_SSE2, depending upon the precision.)

Visual C++ 4.0 and 5.0 had some problems compiling previous FFTW versions correctly, but these were fixed in later releases of those compilers, which however introduced new bugs for new FFTW versions.

VC++ 6.0 also reportedly produces incorrect code for the file reodft11e-r2hc-odd.c (odd-size type-IV DCTs and DSTs) unless optimizations are disabled for that file.

Visual C++ Project Files and Win32 Binaries for FFTW 2.x

Andrew Sterian has put together project workspace files for Microsoft Visual C++ 5.0 that can be used to build FFTW 2.1.3 smoothly from within the IDE. His workspace also allows building the FFTW library as a DLL. Please read through the README.TXT file for important information about using FFTW as a DLL.

You should note that the FFTW package can be compiled as-is on Windows--you simply need to compile all of the .c files in the fftw and rfftw directories. Andrew's files may provide extra convenience, however, especially when building DLLs.

Andrew's package also includes some code to allow the test program to accept command-line parameters in the DOS shell (otherwise, the test program will run in interactive mode on Windows).

You can also find the latest versions of Andrew's packages, as well as prebuilt binaries for Win32 (x86) on his web site.

FFTW 3.x and Borland Delphi

An updated Delphi/Pascal interface (fftw3-delphi.zip) was contributed by Serder Kacar, which includes double and extended precision, wisdom, and threads support, and works with the precompiled Windows DLLs that we supply above.

Kacar's interface was based on work by George Beckett, who contributed a Pascal interface file (fftw_interface.pas) for calling FFTW from Borland Delphi (Pascal). This file is for the single-precision FFTW, but double-precision could be used as well by changing the appropriate types and renaming fftwf_ to fftw_ in the file. Beckett also sent us his notes on calling FFTW from Delphi as well as on compiling FFTW on Windows with the Borland C++ compiler. Finally, he sent us the compiled library via Borland (see also the material from Klaus Maisinger, above). George recommends using the DLLs from Alessio Massaro instead, though, for better performance (note that Alessio's symbol names do not need to be prepended with an underscore, however).

FFTW 2.x and Dev-C++/MinGW

Marek Januszewski has created an FFTW 2.x DevPak for use with Dev-C++ (a MinGW front-end).

Alignment with FFTW 2.x

FFTW includes special hacks to align double-precision variables on the stack for gcc on x86. One of our users, Jonathan Hardwick, has done a detailed study of how these hacks might be extended to Visual C++ and the Intel C++ compiler, and what their performance effects are.

Fortran with FFTW 2.x

FFTW can include Fortran-callable wrapper routines so that you can call the FFTW functions from a Fortran program. These routines are not available automatically on Windows, however.

The problem is that FFTW does not know how to mangle its subroutine names for the Fortran linker (Fortran expects all identifiers to be in a canonical case and format). On Unix systems, our configure script can automatically detect the name-mangling scheme, but this is not possible on Windows. So, you have to specify it manually in order to use the Fortran wrappers.

To do this, go to the end of the fftw/config.h file and #define the appropriate symbol according to the comments. There are eight possibilities: all upper or lower case, and zero, one, or two appended underscores. For example, Digital Visual Fortran (reportedly) uses all lower case with no appended underscore, so you should #define FFTW_FORTRANIZE_LOWERCASE. (If you don't know, you can experiment with a small Fortran and C program until you find something that works. Your Fortran manual may also document how to link with C.) Let us know how it works with your Fortran compiler.

There is another issue to be aware of with Digital Fortran: for every routine that you want to call (e.g. fftw_f77), you must include an instruction like the following at the beginning of your Fortran program:

!DEC$ ATTRIBUTES C, REFERENCE :: fftw_f77

(Thanks to Dima Berkov for this note.)

Timer with FFTW 2.x

FFTW includes a high-precision timer that will be automatically (see below) enabled under Win32, contributed by Andrew Sterian.

We have not tested this code ourselves, however, and it may cause problems for some users. (In particular, problems have been reported with its use of the header file windows.h, which is not recognized in some configurations.) To disable the use of this timing code (and revert to the default clock() function), comment out the line:

#define HAVE_WIN32_TIMER
in config.h.

If you want to make sure that the timer is automatically enabled in your compiler, delete the #if directive surrounding the above line. (This directive is used to automatically enable the timer, but it won't work if your compiler doesn't define __WIN32__, WIN32, or _WINDOWS. Visual C++ and Borland C/C++ should be fine.)

Watcom with FFTW 2.x

Daniel Q. Naiman emailed us to say that he got FFTW running under Watcom's C compiler, version 10.6. He had to #include the file watcom\h\nt\windows.h in config.h to get things running (presumably because of the timer code).

FFTW 1.2

Here are some changes to the Makefile sent in by Robert Jansen to get FFTW 1.2 running under the DOS shell with gcc:

(Many of these changes may not be necessary with other compilers or if you install a DOS-UNIX package like like uxut123 from the Oakland software repository.)


Be sure to let us know if you have to make any other changes to get things working under Windows.
Go back to the FFTW download page.