Assimp  v3.0 (July 2012)
Installation

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

If you develop at Visual Studio 2005, 2008 or 2010, 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 propably 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 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

_HAS_ITERATOR_DEBUGGING=0
_SECURE_SCL=0

in the preprocessor options (or alternatively in the source code, just before the STL is included for the first time). assimp's VC 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 loose 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 (or just skip over it and accept this as a fact).

Then you have to set up a project for the assimp library in your favorite IDE. If you use VC2008 or newer, you can simply load the solution or project files in the workspaces/ folder, otherwise the easiest way is to generate a suitable workspace using CMake .

Then build the library - it should compile and link fine.

Building without boost (CMake: ENABLE_BOOST_WORKAROUND)

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

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:

#define ASSIMP_BUILD_BOOST_WORKAROUND


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.