CAD Exchanger
Desktop app and SDK that read, heal and convert over 30 CAD and mesh formats. A translator, not an authoring tool.
Assimp
A C++ library that reads 40 plus 3D formats into one common scene structure. A developer dependency, not an application.
Format Conversion Open Source
Overview
Assimp reads over 40 3D formats and normalises all of them into one in-memory scene structure, so an engine has to understand that single structure instead of maintaining a parser per format. It has been developed since 2006 and is the ingestion layer inside Qt Quick 3D, the Magnum engine and a long list of custom renderers. It is an offline or editor-time tool by design: the post-processing that makes its output usable is heavy enough that loading assets through it at runtime on a phone is a known route to an out-of-memory kill, so the normal pattern is to import once at build time and serialise to an engine-specific binary. Its position has narrowed as single-format parsers such as ufbx and fastgltf proved faster and more faithful for the formats they cover, but nothing else reads a 1997 Quake model and a modern glTF through the same function call.
Key features
One call for 40 plus formats
The entire API surface for loading is a single ReadFile call that returns a scene object with the same shape no matter what went in. For anyone writing a renderer, this replaces the work of researching and maintaining a parser for every format users might hand them, which is the reason the library exists and still the reason most projects adopt it.
Post-processing that saves weeks of engine work
Triangulation of n-gons, merging identical vertices so index buffers can be used, cache-locality sorting, tangent space generation for normal mapping, and selective stripping of data you do not need. Each of these is dense vector maths that every engine otherwise writes itself. One caveat: the tangent generator is not MikkTSpace, so normal maps baked in Substance or Blender can show seams unless you run the vertices through MikkTSpace separately.
Exporters and a fast intermediate format
Writing is supported for a smaller set than reading, including FBX, glTF, GLB, Collada, OBJ, STL, PLY and 3MF. It also has its own binary format, assbin, which exists precisely for the offline pattern: parse the slow text format once, run the heavy post-processing, serialise the result, and load that at runtime instead.
Bindings well beyond C++
A flat C API underneath makes foreign function interfaces practical, and the ecosystem has produced wrappers for C# and .NET, Python, Rust and Swift. This is how the library ends up inside tools that are not C++ engines at all, such as backend services that normalise user-uploaded models.
BSD licensing that permits static linking into closed source
The library itself is a permissive BSD licence, so it can be modified and statically linked into a proprietary engine with no obligation to publish anything. The detail worth knowing is that it vendors several dependencies with their own licences, MIT, Apache-2.0, zlib and others, and those obligations flow into whatever you ship.
Pros and cons
What users consistently praise
- Format breadth no alternative matches, from modern glTF to game formats from the 1990s, through one API
- The post-processing suite removes weeks of foundational engine work: triangulation, vertex welding, tangent generation and cache optimisation
- Permissive BSD licence allows static linking into closed source commercial products
- Genuinely active: version 6.0.5 shipped April 2026 and commits continue daily, with roughly 900 contributors over the project's life
- Deeply embedded in the ecosystem, including Qt Quick 3D and the Magnum engine, so bugs get found by a large user base
- Bindings exist for C#, Python, Rust and Swift, so it is not limited to C++ projects
What users consistently criticise
- FBX skeletal animation is the long-standing weak point: the importer injects synthetic nodes to hold pivot data, which preserves the visual result while corrupting the bone hierarchy for retargeting
- Material handling is built around the older Phong model, so glTF PBR material graphs get flattened and modern shading parameters often have to be dug out with custom code
- Not thread safe at the data level; concurrency requires one independent importer instance per thread rather than sharing a scene
- Memory use is heavy and leaks have been documented when parsing throws mid-file, since the cleanup path is bypassed
- Around 70 CVEs on record, which matters a great deal if it is exposed to untrusted uploads rather than local trusted assets
- Build and link friction is a recurring complaint, particularly toolchain mismatches on Windows, which is why most projects install it through a package manager
- Blender .blend support is deprecated, and specialised parsers now beat it on both speed and fidelity for FBX and glTF specifically
Recurring themes across third-party user reviews (G2, Capterra, TrustRadius).
Videos
Pricing
Is Assimp free?
Assimp is free and open source. There is no paid edition to upgrade to, and no feature is held back behind a licence.
Open Source.
Best for
Anyone writing their own renderer or engine
The classic case. If you are building on OpenGL, Vulkan or DirectX and need to load whatever asset a user supplies, Assimp is still the shortest path from an arbitrary file to vertex buffers, and the post-processing flags cover most of what you would otherwise write yourself.
Asset pipeline and batch conversion tooling
Backend services that normalise directories of mixed-format models into one internal format. Because each importer instance is self-contained, this parallelises cleanly by running one instance per thread, which is the supported way to use it concurrently.
Anyone dealing with old or obscure formats
Its coverage of legacy game formats, Quake and Half-Life models, Collada files, motion capture data, is unmatched and largely unmaintained anywhere else. For archival work or reverse engineering old assets there is often no alternative at all.
Who should look elsewhere
Anyone who wants an application rather than a dependency
This is a library you compile against, not a program you run. There is no interface and no double-clickable converter. If you want to convert a file without writing code, the tools built on top of it, or a desktop converter, are what you are looking for.
Production character animation from FBX
FBX carries a transformation stack with pre-rotation, post-rotation and pivot offsets that does not fit a single matrix per node. Assimp compensates by injecting synthetic nodes into the skeleton, which preserves the deformation but breaks the bone hierarchy for retargeting. Turning that off instead breaks the animation. Godot hit this hard enough to strip the library and eventually replace it with ufbx.
Runtime loading on mobile
Post-processing allocates aggressively, and doing it on a phone while the application is running is a documented way to be terminated by the OS. The library was designed to run at build time on a workstation, and that is where it should stay.
Server-side ingestion without sandboxing
NVD lists around 70 CVEs against Assimp, overwhelmingly heap overflows, use-after-free and segmentation faults reached through malformed input files. On a developer workstation parsing trusted assets that is a crash. On a server parsing files that strangers uploaded it is a remote code execution surface, so it needs isolating.
Frequently asked questions
Can I use Assimp in a commercial closed source product?
Yes. The library is under a permissive BSD licence that allows modification and static linking into proprietary software, with the obligation to retain the copyright notices. The part that catches teams out is that Assimp vendors several third-party dependencies in its source tree, under MIT, Apache-2.0, zlib and other terms, and those notices have to be carried into whatever you ship. It is worth generating a licence inventory from an actual build rather than assuming BSD covers everything.
Why do my FBX animations import as a mess of triangles?
FBX stores transforms as a stack including pre-rotation, post-rotation and pivot offsets, which does not reduce cleanly to one matrix per node. Assimp inserts extra synthetic nodes into the hierarchy to hold that data, and the deformation then looks correct while the skeleton no longer matches the original rig. Disabling that behaviour through the preserve-pivots configuration gives a clean hierarchy but drops the offsets, which is when the character collapses. If FBX animation is central to your pipeline, a dedicated FBX parser is the better tool.
Should I load models with Assimp at runtime?
Generally not. It is built as an editor-time or build-time tool, and its post-processing is memory hungry enough that running it inside a shipping mobile application risks the operating system terminating the process. The established pattern is to import and post-process offline, then serialise to a format your engine loads directly, which is what the library's own assbin format is for.
Does it read Blender .blend files?
Support exists historically but is deprecated and should not be relied on. The maintainers' reasoning is that .blend is undocumented, changes frequently and carries a large amount of internal application state that has nothing to do with asset interchange. Exporting from Blender to glTF or FBX first is the supported route.
Is it safe to run Assimp on files that users upload?
Not without isolating it. NVD lists roughly 70 CVEs against the library, mostly heap buffer overflows, use-after-free and crashes triggered by malformed geometry. That risk profile reflects its origin as an offline tool operating on assets you already trust. Once it sits behind an upload form the same bugs become a remote code execution surface, so it belongs in a sandboxed or isolated process with resource limits.
Is Assimp still the right choice in 2026?
It depends on whether you value breadth or fidelity. For a single modern format, purpose-built parsers now win clearly: ufbx for FBX and fastgltf or cgltf for glTF are faster, more accurate and safer, and Godot moved to ufbx in 4.3 after years of FBX problems. Assimp remains the answer when you cannot predict what file will arrive, or when the file is old enough that nothing else still reads it.
Latest official news
Alternatives to Assimp
See all Format Conversion ›
MeshLab
Open source system for processing and editing 3D triangular meshes, widely used for scan cleanup, repair and format conversion.