Blender-FLIP-Fluids: the source of a fluid engine that ships as a paid addon

A fluid engine that ships inside Blender

The FLIP Fluids addon is a tool that helps you set up, run and render liquid simulation effects in Blender, and it is built around a custom fluid engine that the project has been developing since 2016 with a large focus on tightly integrating the simulator into Blender as an addon.

The engine uses the FLIP simulation technique, which is also found in many other professional liquid simulation tools. FLIP, a fluid implicit particle method, moves particles through the domain and reinterpolates them onto a grid, which is what gives liquids their churning behaviour compared with a grid-only solver that gets smoothed away over time. The choice of technique here is the reason the results are described as high quality.

The integration claim is the part worth examining. A fluid simulator that is a separate application with an exchange format is a pipeline, with an export step, a version mismatch risk and a round trip. An addon that runs the solver inside the host, with the simulation domain as a scene object and the cache written where Blender expects it, is a different workflow, and the README's phrasing is that it just feels like a native Blender tool.

The primary language is C++, the default branch is `master`, and the last push was on 2026-08-24. The recent releases are v1.8.8 from 2026-07-27, v1.8.7 from 2026-07-14 and v1.8.6 from 2026-03-24. The project is not archived.

The intended user is a Blender artist or technical director who needs convincing liquid in a shot. There is also a second audience, which is the one this repository serves most directly: developers who want to read a production fluid engine in C++, or build it themselves.

Three licences in one repository

The licence section is the most important thing to understand before you clone anything, because the answer is not one licence.

The program uses multiple licenses, and the details live in `LICENSE_GPLv3.md`, `LICENSE_MIT.md` and `LICENSE_Standard_Royalty_Free.md`. In general, the Blender addon code is licensed under the GPL, the FLIP Fluids simulation engine is licensed under the MIT license, and some addon content uses a Standard Royalty Free license.

That third category is the one with a commercial dimension. It may cover content such as example scene files, media, artwork, data, and features that rely on this content, with the Mixbox color blending features given as an example. And the README states clearly that this content will only be included within the paid addon and will not be available on the GitHub project page, while also noting that the addon is still completely usable without this content.

The practical reading is that the code is open, the content is not, and the two are separable. The mechanics of telling them apart are documented too: source code files will state their license at the top of the file, and assets will include a license file and information in their containing directory. So a reader can tell, file by file, what they are looking at and what the terms are.

The project metadata records the repository licence as GPL-3.0, which covers the addon code, but the repository as a whole is a mixture, and anyone redistributing a build has to respect all three files rather than the headline.

For the engine's MIT licence specifically, that is the permissive end of the arrangement. It means the simulation engine code, the part that is actually the difficult engineering, can be read, studied, reused and modified under terms that do not oblige you to publish anything you build on top of it, which is a meaningfully different proposition from the addon wrapper.

The demo addon is not the product

The distribution model is worth understanding before evaluating the code, because it explains what is in the repository and what is not.

The full FLIP Fluids addon is sold as a paid licence on official marketplaces where the addon is sold, and the README points to a list of those marketplaces. Purchasing a license entitles you to the full feature set and content, tool support, and helps ensure the continued development of the addon. The project states that it has been developed on a full-time basis since its initial release in May 2018, and that the development is funded solely through marketplace sales, with the team describing itself as small.

So this repository is the source of a commercial product, published in a form that lets people read the code and the engine while the content layer stays paid. That is an unusual and fairly generous arrangement for a commercial application, and it is also the reason the repository is worth reading.

Support is tied to the purchase. You can get support by reading the documentation and wiki, or through the marketplace messaging systems where you bought the product, and support is granted to all customers who have purchased a license. The wiki is at the Blender-FLIP-Fluids-Beta repository, and there is a separate page for the free demo addon, the FLIP Fluids Demo Addon, which is a cut-down version linked from the README.

The key features are not enumerated in this README. Instead it directs you to the marketplace product pages for information on features, which means the feature list lives with the vendors rather than in the source tree, and that the open repository is not a complete specification of the product.

The one piece of feature information that is in the README is about content, and it is the exception that proves the point: the example scenes, the media, and the features that depend on them are paid content, while the addon remains usable without them.

Building the engine: C++17, CMake, Make, Alembic

The build section is where this repository becomes concrete, and it starts with a warning about expectations. To build the FLIP Fluids addon and its external dependencies, some programming experience and prior experience in building C/C++ applications with CMake is strongly recommended, and some familiarity with the C/C++ compiling, linking and building process is recommended for debugging and resolving any errors or warnings encountered.

The required toolchain is listed precisely.

A compiler that supports C++17. On Windows, MinGW is the only supported compiler, on macOS Clang is recommended, and on Linux GCC is recommended. CMake to generate the appropriate solution, project or Makefiles. GNU Make to compile and build the FLIP Fluids simulation engine. And Alembic with its external dependencies, which means Imath 3.

That last pair is the interesting dependency. Alembic is the geometry and animation interchange format used across the film and games pipelines, and pulling it in means the simulator can hand off cache and geometry in a format other tools understand. Imath 3 is its maths library dependency, and the version is pinned because the API changed across major versions.

Optional is Python 3.3 or newer, which is only needed if you want to use the automated build script.

The stated system requirements for running the addon are: Windows, macOS or Linux, Blender 4.5 to 5.2 compatible, a 64-bit Intel or AMD or Apple Silicon multi-core processor, and 8 GB RAM minimum with 16 GB or more highly recommended.

The Blender version range is the constraint to plan around, because Blender's Python API and add-on interface change between releases, and an addon built for 4.5 will not necessarily load cleanly in 5.2.

The automated build script and its flags

The repository includes an automated build script to help you build and compile the addon, and using it requires Python 3.3 or newer.

From the root of the project directory:

python build.py

Once the build succeeds, the addon and the installation .zip file will be located in the `build/bl_flip_fluids/` directory.

The script's flags are the interesting part, and they cover the three situations where a default build fails.

The first is finding the tools. The build script works best if CMake and GNU Make are located in your system PATH variable, but if not, you may also specify their locations when executing the script with the `-cmake-path path/to/cmake` and `-make-path path/to/make` flags.

The second is packaging the shared libraries. The simulator relies on the Alembic and Imath 3 external dependencies, and if these shared libraries and each of their own dependencies are not located in your system PATH variable, they should be packaged within the addon by providing a list of filepaths with the `-package-dependencies path/to/lib1 path/to/lib2` flag. That flag is what turns a locally working build into a redistributable one, since the alternative is requiring every user of the addon to have Alembic installed.

The third is the help flag, `python build.py --help`.

The packaging behaviour is worth noting as a design decision. A Blender addon that depends on native libraries has a distribution problem, because Blender's own extension system assumes a self-contained Python package. Bundling the compiled libraries into the addon zip is the solution, and the flag that does it is one of the three things the script offers beyond a plain build.

Manual builds, and where the output lands

The manual path is documented separately for Windows and for Linux and macOS, and it is the two-line CMake and make sequence you would expect.

On Windows:

mkdir build
cd build
cmake .. -G "MinGW Makefiles"
make

On Linux and macOS:

mkdir build
cd build
cmake ..
make

Either way, once successfully built the FLIP Fluids addon will be located in the `build/bl_flip_fluids/` directory.

The generator name on Windows is the detail that matters, because it is the only supported path there. The MinGW Makefiles generator produces makefiles rather than a Visual Studio solution, which means the addon is built with the same toolchain everywhere, and it is why the README can say that MinGW is the only supported compiler for Windows. A developer on Windows who opens this in Visual Studio is on an unsupported path.

The top level of the repository matches the two-part structure of the project. There is `CMakeLists.txt` at the root, the `src/` directory holding the sources, `build.py` and `__init__.py` for the Python side of the addon, the three licence files, and `.github/` for the repository's own configuration. The output directory name, `build/bl_flip_fluids/`, is the same in the manual and the automated path, which means the two build routes converge on the same artefact layout and the same installation instructions in the Addon Installation and Uninstallation guide.

There is no CI configuration in the tree that builds the addon for you, so a build is a local operation with a real toolchain requirement, and the README's advice to be comfortable with C and C++ and CMake is a prerequisite rather than a warning about edge cases.

Where FLIP Fluids is the wrong choice

There are three cases where this project does not fit, and the first is a licensing one rather than a technical one.

The first is when you need the example scenes, the media, the artwork or the features that depend on them. Those are paid content and they are not in the repository, and the README says so without hedging. A team that wants a reference scene to start from, or the Mixbox color blending, cannot get it from this source tree.

The second is when your Blender version is outside 4.5 to 5.2. The addon is not version agnostic, and building against a different release is at best undocumented. On a machine locked to a specific Blender build, that constraint decides the question before anything else.

The third is when you need a general purpose fluid solver for another host application. The engine is MIT licensed and readable, so it is technically available, but the integration work is substantial: the cache format, the scene representation, the mesh generation and the render hooks all assume Blender. Extracting the solver means reimplementing the interface, and the MIT licence grants you the right to do that without any of the integration.

The alternative approach, for comparison, is the free FLIP Fluids Demo Addon, which is linked from the README and is the vendor's own cut-down. The difference in approach is that the demo gives you a working subset with the vendor's support path, while the source gives you the code and none of the content, and the paid product gives you both. A reader who wants to understand the engine should read this repository; a reader who wants to render a liquid this afternoon should use the demo, and a reader with a commercial licence should use the product and then send the bug reports upstream.

Editorial conclusion

Adopt the source if you want to read a production fluid engine, contribute to it, or build the addon yourself from the published source, since the repository is a complete build environment with documented dependencies and both an automated and a manual build path. Do not adopt it expecting the paid content, because the example scenes, media, artwork and the features that depend on them ship only with the paid addon and are absent from the GitHub tree. Verify three things first: that your Blender version is in the supported range of 4.5 to 5.2, that Alembic and Imath 3 and their own dependencies resolve on your system or that you package them with the `-package-dependencies` flag, and that the compiler on your platform is the supported one, since MinGW is the only supported compiler on Windows.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. README
4. Releases
5. rlguy/Blender-FLIP-Fluids on GitHub