Using the pre-built libraries with Visual C++ 8/9

If you develop at Visual Studio 2005 or 2008, you can simply use the pre-built linker libraries provided in the distribution. Extract all files to a place of your choice. A directory called "assimp" will be created there. Add the assimp/include path to your include paths (Menu->Extras->Options->Projects and Solutions->VC++ Directories->Include files) and the assimp/lib/<Compiler> path to your linker paths (Menu->Extras->Options->Projects and Solutions->VC++ Directories->Library files). This is neccessary only once to setup all paths inside you IDE.

To use the library in your C++ project you have to include either <assimp/Importer.hpp> or <assimp/cimport.h> plus some others starting with <types.h>. If you set up your IDE correctly the compiler should be able to find the files. Then you have to add the linker library to your project dependencies. Link to <assimp_root>/lib/<config-name>/assimp.lib. config-name is one of the predefined project configs. For static linking, use release/debug. See the sections below on this page for more information on the other build configs. If done correctly you should now be able to compile, link, run and use the application. If the linker complains about some integral functions being defined twice you probably have mixed the runtimes. Recheck the project configuration (project properties -> C++ -> Code generation -> Runtime) if you use static runtimes (Multithreaded / Multithreaded Debug) or dynamic runtimes (Multithreaded DLL / Multithreaded Debug DLL). Choose the assimp linker lib accordingly.

Please don't forget to also read the Microsoft Compilers and the C++ Standard Library section on MSVC and the STL.

Microsoft Compilers and the C++ Standard Library

In VC8 and VC9 Microsoft introduced some Standard Library debugging features. A good example are improved iterator checks and various useful debug checks. The problem is the performance penalty that incurs with those extra checks.

Most of these security enhancements are active in release builds by default, rendering assimp several times slower. However, it is possible to disable them by setting

in the preprocessor options (or alternatively in the source code, just before the STL is included for the first time). assimp's vc8 and vc9 configs enable these flags by default.

If you're linking statically against assimp: Make sure your applications uses the same STl settings! If you do not, there are two binary incompatible STL versions mangled together and you'll crash. Alternatively you can disable the fast STL settings for assimp by removing the 'FastSTL' property sheet from the vc project file.

If you're using assimp in a DLL/SO: It's ok. There's no STL used in the binary DLL/SO interface, so it doesn't care whether your application uses the same STL settings or not.

Another option is to build against a different STL implementation, for example STlport. There's a special Building against STLport section that has a description how to achieve this.

Building the library from scratch

To build the library on your own you first have to get hold of the dependencies. Fortunately, special attention was paid to keep the list of dependencies short. Unfortunately, the only dependency is boost which can be a bit painful to set up for certain development environments. Boost is a widely used collection of classes and functions for various purposes. Chances are that it was already installed along with your compiler. If not, you have to install it for yourself. Read the "Getting Started" section of the Boost documentation for how to setup boost. VisualStudio users can use a comfortable installer from http://www.boost-consulting.com/products/free. Choose the appropriate version of boost for your runtime of choice.

If you don't want to use boost, you can build against our "Boost-Workaround". It consists of very small implementations of the various boost utility classes used. However, you'll lose functionality (e.g. threading) by doing this. So, if you can use boost, you should use boost. Otherwise, See the NoBoost-Section later on this page for the details of the workaround.

Once boost is working, you have to set up a project for the assimp library in your favorite IDE. If you use VC2005 or VC2008, you can simply load the solution or project files in the workspaces/ folder, otherwise you have to create a new package and add all the headers and source files from the include/ and code/ directories. Set the temporary output folder to obj/, for example, and redirect the output folder to bin/. Then build the library - it should compile and link fine.

The last step is to integrate the library into your project. This is basically the same task as described in the "Using the pre-built libraries" section above: add the include/ and bin/ directories to your IDE's paths so that the compiler can find the library files. Alternatively you can simply add the assimp project to your project's overall solution and build it inside your solution.

Building without boost.

The Boost-Workaround consists of dummy replacements for some boost utility templates. Currently there are replacements for

• boost.scoped_ptr
• boost.scoped_array
• boost.format
• boost.random
• boost.common_factor
• boost.foreach
• boost.tuple
• boost.make_shared

These implementations are very limited and are not intended for use outside assimp. A compiler with full support for partial template specializations is required. To enable the workaround, put the following in your compiler's list of predefined macros:

If you're working with the provided solutions for Visual Studio use the -noboost build configs.

assimp_BUILD_BOOST_WORKAROUND implies assimp_BUILD_SINGLETHREADED.
See the assimp_st section for more details.

Windows DLL Build

assimp can be built as DLL. You just need to select a -dll config from the list of project configs and you're fine.

NOTE: Theoretically, assimp-dll can be used with multithreaded (non-dll) runtime libraries, as long as you don't utilize any non-public stuff from the code folder. However, if you happen to encounter very strange problems, try changing the runtime to Multithreaded (Debug) DLL.

Building against STLport

STLport is a free, fast and secure STL replacement that works with all major compilers and platforms. To get it, download the latest release from <stlport.org>. Usually you'll just need to run 'configure' + a makefile (see their README for more details). Don't miss to add <stlport_root>/stlport to your compiler's default include paths - prior to the directory where your compiler vendor's headers lie. Do the same for <stlport_root>/lib and recompile assimp. To ensure you're really building against STLport see aiGetCompileFlags().
In our testing, STLport builds tend to be a bit faster than builds against Microsoft's C++ Standard Library.