The Free and Open Productivity Suite
Apache OpenOffice 4.1.5 released

Building under Windows

This document refers to older versions of only. If you intend to build the snapshot No. 638 or later, go here!

This document describes the requirements and actions that you need to build on Windows. Commands you have to type on the keyboard follow this syntax throughout this document:

config_office> winenv.bat

In this example, the script winenv.bat is executed in the directory config_office under a 4NT shell. Unless stated otherwise, all commands appearing in this document should be entered from a 4NT shell. $SRC_ROOT will denote the directory in which the source code of is stored.

Table of contens:


All those who have done a build of before may use this section as a reminder. You are well advised to check the release notes at and the section Build Requirements in this document to inform yourself about changes since the previous releases.

Detailed step-by-step build descriptions are given from the next section on.

You can perform a full build, or you can build an individual project using a prebuild version.

Overview of Performing a Full Build

To perform a full build, you need to follow these steps:

  1. Get the source code, either from the download webpage at, or alternatively via a check-out from the cvs tree against a release tag, e.g. OpenOffice614.
  2. Run the configure script in a cygwin bash shell to check all requirements and to create the script winenv.bat, or edit the sample file winenvsample.bat.
  3. Run the winenv.bat script to set all environment variables.
  4. Build using the dmake tool.
For detailed build instructions, see the section Building a Full Build of the Office Suite in this document. The installation procedure is described at the end of this document.

Overview of Building an Individual Project

You can use a prebuild version to build an individual project. Having a prebuild version is neccessary because the individual project you want to build could depend on other projects. A project builds a particular component of For example, the Word Processing project builds the Word Processing application. To build an individual project, you must follow these steps:

  1. Download the appropriate solver tarballs from the download webpage at, i.e. for 614 the solver tarball solver614_win32intel.tar.gz.
  2. Check out the modules for the project that you want to build from the CVS tree. If your project uses the resources module, res, check out this module also. You can, of course, also download the entire source from the download webpage ( However, it is not possible to download individual modules there.
  3. Check out the module config_office. This is always necessary to create the build environment.
  4. Also check out the module solenv. This module provides the build tools.
  5. Unpack the solver tarball.
  6. Run the configure script in a cygwin bash shell to check all requirements and to create the script winenv.bat, or edit the sample file winenvsample.bat.
  7. Run the script winenv.bat to set all environment variables.
  8. Build each module against the prebuild solver using the dmake tool.
For detailed build instructions, see Building Individual Projects with a Prebuild.

Build Requirements

Before you start building, you must ensure that your system satisfies the recommended software and hardware requirements for the type of system you are working on. For Windows, these are as follows:

Build Requirements

The following external requirement is only necessary for older snapshots:

Hardware Requirements

External Components

The code contains some further external components which are already provided. If you are interested in details about these, look at the External Components webpage at

Get the source code

You have two options to get the source code:

Generating the Build Environment and Build Tools

Ideally, in keeping with the principles of open source, you would use an open source shell to build on a computer running a Win32 operating system. However, this is not possible at present. You must use a non-open source shell to build on a computer running a Win32 operating system: the 4NT command shell.

In the future, it may be possible to build on a Win32 system using the Cygnus bash shell. However, this requires syntax changes to the makefiles that the build uses. This is a future project for

However, the Cygnus bash shell is needed to run the configure script which generates the build environment. The configure script checks that all software, hardware, and system requirements for the build are satisfied, and it creates a configuration file called winenv.bat that you then execute to set all necessary build environment variables. Alternatively, you can edit the winenvsample.bat file. This configuration file will be moved into the SRC_ROOT directory. A top-level makefile script makefile.rc and the script bootstrap in the config-office directory will be moved into SRC_ROOT as well. This is due to technical reasons: The SRC_ROOT directory in the cvs tree can only hold directories. On the other hand, the top-level makefile.rc should logically be placed in the top-level directory SRC_ROOT. The cvs tree holds these files in config_office and configure copies them up.

In case you adjust the sample file winenvsample.bat to your needs rather then running the configure script, you have to copy it by hand to SRC_ROOT and name it winenv.bat. Copying the file makefile.rc from $SRC_ROOT/config_office to $SRC_ROOT had to be done by hand as well in this case.

If you experiment with newest sources from the cvs-tree, mind that updates to the configure process do not happen via updates of configure (the script file) but via the file The configure script itself is created from using the autoconf command. In this case, you would run commands like the following:

$SRC_ROOT> cd config_office
config_office> cvs update
get a bash shell
config_office>bash autoconf
exit the bash shell

to update the configure script. If you only use code from the snapshot releases on the web, you don't need to be concerned about this.

To run the configure script, do the following:

open a cygwin bash shell.

$SRC_ROOT> cd $SRC_ROOT/config_office
config_office> bash configure --with-stlport4-home=(path)
path is the absolute path pointing to your STLPort installation, given in a cygwin-specific notation. If, for instance, STLport resides in C:\STLport-4.0, path would be //C/STLport-4.0. Exit the bash shell afterwards. configure will probably also ask you for the location of the Java Development Kit 1.2.2, the Microsoft compiler, and the assembly compiler. In case they reside in C:\jdk1.2.2, C:\PROGRA~1/MICROS~3/VC98, and C:\ml, their locations have to be entered as //C/jdk1.2.2), //C/PROGRA~1/MICROS~3/VC98, and //C/ml, respectively. The configure script should find everything else by itself. If not, you can always specify it explicitly, for instance for Perl with the option --with-perl-home=//C/Perl if it resides in C:\Perl. Note that all paths given here are for the sake of an example only.

There are a number of further options that you can use with the configure script. To display these options, type the following command:

config_office> bash configure --help
Currently, the configure scripts ends for Windows with an error message /bin/sh: No such file or directory. This is a bug, but doesn't lead to any problems and can be ignored.

The option --with-stlport4-home is a requirement. For more information on the options that you can use with the configure script, see the Build Environment document at

After running configure, you have to execute the configuration file which sets all environment variables. An example of how this file called winenv.bat looks like with the example paths given above is shown here.

Alternatively to running the configure script, you can make use of the sample file winenvsample.bat in $SRC_ROOT/config_office, adjust it to your setup, and copy it to $SRC_ROOT as winenv.bat. Note that in this case you also have to copy makefile.rc by hand.

$SRC_ROOT> winenv.bat

edit $SRC_ROOT/config_office/winenvsample.bat

$SRC_ROOT> cp config_office/winenvsample.bat winenv.bat
$SRC_ROOT> cp config_office/makefile.rc makefile.rc
$SRC_ROOT> winenv.bat

Build Instructions

Building a Full Build of the Office Suite

Now you are ready to build To build the entire suite, all you have to do (after having created the environment as described above) is to run dmake from the top-level directory. This will take several hours.
$SRC_ROOT> dmake
If you are interested in the order in which the individual modules are build, type
$SRC_ROOT> dmake -n

The following table shows the time required to build on a system with a particular specification. You can use these details to estimate the time required to build on your system.

Architecture Intel
Processor Pentium III
Processor speed 600 MHz
RAM 256 MB
Hard Disk 6 GB SCSI
Time ~20 h

Building Individual Projects with a Prebuild is organised in several projects. For example, the Word Processing Project. These in turn consist of several modules, organised in separate directories. The source contains approximately 90 modules.

You can build any project or module individually. Building modules individually should not be misunderstood as reducing to a special application, say, for instance, the spreadsheet application. The program will always consist in the entire office suite: text processor, spreadsheet, drawing application etc.. Building individual modules comes in handy if you want to develop on a certain module. Most modules will depend on other modules to be already built. In other words, all modules must build in a particular order. To avoid building all modules which are prerequisites of the module of your interest, you can make use of a pre-build solver tree against which you can build any module.

For more information on modules and on the sequence that they build in, and on the dependencies, see

You have to download the solver tree as a tarball solver609_win32int.tar.gz from the Download page at and unpack it in the $SRC_ROOT directory:

$SRC_ROOT> gunzip solver609_win32int.tar.gz
$SRC_ROOT> tar -xvf solver609_win32int.tar

In order to create the build environment and build tools, you also have to check out the config_office module and solenv.

To build a project, you build each of its modules individually in their directory with the dmake tool.

$SRC_ROOT/(module-name)> dmake
Files called makefile.rc in each directory with further subdirectories iterate through all directories of the module and exectues dmake in each of them (just like the top-level makefile.rc does when building the entire office suite). The last or second to last directory is usually module-name/util which is responsible for linking one or more shared libraries.

Building a Project with Debug Information

To rebuild a complete project with debug information, remove all object files by removing the ( until snapshot 619) directory. Then run dmake with the debug option set to true:

$SRC_ROOT/(module)> rm -rf
$SRC_ROOT/(module)> dmake debug=true

Instructions to Build an Installation Set

When you have completed the build, you need to do the following to install and set up the office suite:

  1. From the top-level directory, run the dmake install command, or run dmake in the directory instsetoo:
    $SRC_ROOT> dmake install
    $SRC_ROOT> cd instsetoo
    instsetoo> dmake
    Languages other than english (provided the language option was set in configuring) can be build with the option LANGEXT. For instance for french:
    $SRC_ROOT/instsetoo> dmake LANGEXT=33
    The parameter 33 stems from the international phone code for France.
  2. Change directory to $SRC_ROOT/instsetoo/ and execute the setup binary:
    $SRC_ROOT> cd instsetoo/
    normal> ./setup

Apache Software Foundation

Copyright & License | Privacy | Contact Us | Donate | Thanks

Apache and the Apache feather logo are trademarks of The Apache Software Foundation. OpenOffice, and the seagull logo are registered trademarks of The Apache Software Foundation. Other names appearing on the site may be trademarks of their respective owners.