# Dust3D: low poly modeling with built-in rigging and UV unwrapping > Dust3D is an MIT-licensed, cross-platform modeling tool for low poly game assets and 3D printing, built on Qt 6 and C++17. Its distinguishing feature is that rigging, procedural animation and UV unwrapping ship inside the modeler rather than in a separate pipeline stage. **huxingyi/dust3d** — Dust3D is a cross-platform 3D modeling software that makes it easy to create low poly 3D models for video games, 3D printing, and more. - Repository: https://github.com/huxingyi/dust3d - Website: https://dust3d.org/ - Stars: 3,560 · Forks: 270 - Language: C++ - License: MIT - Published: 2026-09-23 · Updated: 2026-09-23 · Language: en - Canonical page: https://hysenlabs.com/projects/huxingyi-dust3d ## What Dust3D solves for low poly game and print work Low poly modeling is not hard because the shapes are complex. It is hard because the work is split across tools. You block out geometry in one application, unwrap UVs in a second, build a skeleton in a third, then re-import everything and hope the vertex order survived. Each hop is a place where the mesh and the rig drift apart. Dust3D's stated position is that it makes it easy to create 3D models for video games, 3D printing, and more, and that rigging, procedural animation and UV unwrapping are built in. The export targets named in the README are GLB and FBX. Those are the two formats game engines and DCC tools actually consume, so the intent is clear: produce a finished, rigged, textured asset, not a raw mesh. The audience follows from that. It is for people making low poly props, characters and creatures where the silhouette does the work and the poly budget is tight. It is also for 3D printing, where a watertight mesh matters more than a rig. It is not aimed at sculptors or at anyone doing subdivision surface modeling with millions of polygons. ## How the Qt application, C++17 core and export path fit together The repository splits into a top-level application/ directory and a dust3d/ library directory, with third_party/ holding vendored dependencies and ci/ plus .github/ holding the build and release automation. The application directory is what qmake builds. That separation matters if you want to link the modeling core into your own tool rather than run the GUI. The build system is qmake, not CMake. The README instructs you to change into dust3d/application and run qmake to generate a Makefile, then make. On Windows the documented path is different: open the .pro file in Qt Creator, pick Debug or Release, and press Run. There is no documented CMake configuration, and the README does not describe a headless or command-line build target. The dependency set is small and explicit. Qt 6 is recommended, Qt 5 also works, and the required modules are qtbase, qtsvg and qtmultimedia. A C++17 compiler is required. Nothing in the README mentions a scripting layer, a Python API, or a plugin SDK, so extension work means working in C++ against the dust3d/ library. The release process is documented and worth reading because it tells you what the shipped binaries are. The maintainer merges to master with a CHANGELOGS update, runs git tag and git push origin , waits for the Actions/release workflow to finish, then attaches three artifacts to the GitHub release: Dust3D-win32-x86_64.zip, Dust3D-x86_64.AppImage and Dust3D.dmg. Those three names are the honest answer to what platforms get prebuilt binaries. A Linux user gets an AppImage, not a distro package. ## Building Dust3D from source and making a first model The README does not give a one-line installer. It gives build instructions, and the binary downloads live on the GitHub releases page under the artifact names above. If you want the current code rather than the last tagged build, you build it. Start by cloning the repository. ```bash git clone https://github.com/huxingyi/dust3d.git ``` On Ubuntu or Debian, install the three Qt modules the README requires, plus the OpenGL development headers. ```bash sudo apt install qt6-base-dev qt6-svg-dev qt6-multimedia-dev libgl-dev ``` On Fedora the equivalent package names differ, and the README lists them separately. ```bash sudo dnf install qt6-qtbase-devel qt6-qtsvg-devel qt6-qtmultimedia-devel ``` On macOS, Qt comes from Homebrew and the compiler toolchain from Xcode. ```bash brew install qt xcode-select --install ``` With dependencies in place, the macOS and Linux build is two commands from the application directory. The first generates the Makefile, the second compiles. ```bash cd dust3d/application qmake make ``` On Windows the README does not use the command line. It says to open Qt Creator, choose Open Project from the File menu, navigate to the project directory dust3d/application, open the .pro file, select Debug or Release from the dropdown at the bottom left, and click Run. That is the whole documented Windows workflow. For a first real use, launch the built application and start a new document. The README does not walk through the modeling viewport, so the practical starting point is the dust3d.org site, which the README points to for more information. What you should expect from the tool description is a low poly mesh you can rig and unwrap in the same session, then export as GLB or FBX. If the window opens and the mesh viewport renders, the Qt and OpenGL dependencies are satisfied. If it fails at startup, the usual cause is a missing qtsvg or qtmultimedia module. ## Where Dust3D stops being the right tool The README is a build and release document, not a feature manual. It does not describe the modeling operations, the rigging interface, the procedural animation system, or the UV unwrapping algorithm. That silence is the first limitation: there is no in-repo specification of what the tools do or how they behave at the edges, so evaluating it means running it. There is no documented import path. The README names GLB and FBX as export formats but says nothing about bringing existing meshes in. If your workflow assumes you can load a reference model, modify it and re-export, the documentation does not confirm that. The platform story is uneven. Windows, macOS and Linux all have build instructions, but only three release artifacts are named, and one of them is an AppImage. An AppImage is a single executable you run directly; it does not integrate with a package manager, so updates are manual. If your team policy requires distro-packaged software or a signed installer, this does not match. Finally, the tool is a specialist. If you need sculpting brushes, boolean-heavy hard surface work, or a node-based material system, a general DCC application covers that ground and Dust3D does not claim to. Choosing it for a high-poly character is choosing the wrong instrument. ## Dust3D against Blender and Blockbench Blender is the obvious comparison and the difference is scope, not quality. Blender is a full pipeline: modeling, sculpting, rigging, animation, simulation, rendering and video editing, with a large Python API. Dust3D is a single-purpose modeler whose selling point is that rigging, procedural animation and UV unwrapping are built into the modeling session. If you already know Blender, Dust3D's value is the shorter path from blockout to rigged low poly asset, not raw capability. Blockbench is the closer comparison on the low poly side. It is built around block-and-box modeling with a texture-first workflow and targets voxel-style and Minecraft-adjacent assets. Dust3D's README describes a different emphasis: rigging, procedural animation and UV unwrapping, with GLB and FBX export. So the split is roughly Blockbench for box-modeled, texture-driven assets, and Dust3D for low poly meshes where the rig and the UV layout are produced by the tool. Neither comparison is settled by the repository. The README gives no feature matrix and no benchmark, so the honest way to decide is to build Dust3D, make one asset end to end, and compare the result in your engine. ## Licence, maintenance and what an upgrade costs Dust3D is licensed under the MIT License, and the README links to the LICENSE file in the repository. MIT is permissive: it allows use, modification and redistribution, including in commercial and closed-source products, provided the licence text and copyright notice are preserved. That is a general description of the licence, not legal advice; check the LICENSE file and your own counsel for your situation. The practical consequence is that you can ship models made with Dust3D, and you can embed the dust3d/ library in a commercial tool, without a copyleft obligation on your own code. That is a meaningful difference from GPL-licensed modeling tools, and it is the reason the licence line matters as much as the feature list here. Maintenance looks current. The repository is not archived, and the last push was on 2026-08-17. The most recent release listed is 1.1.6, dated 2026-06-08, following 1.1.5 on 2026-06-05 and 1.1.4 on 2026-06-04. That cluster of three releases in five days suggests a period of active patching rather than a slow trickle. Upgrade cost is where the build-from-source model bites. There is no documented migration guide and no documented file format versioning in the README, so it does not say whether a project file saved in 1.1.4 opens cleanly in 1.1.6. The CHANGELOGS file at the repository root is where release notes live, and the README's own release process says the release description is copied from it. Read CHANGELOGS before moving a project between versions. If you rely on the AppImage, plan on downloading a new file for each upgrade, since nothing in the README describes an in-application updater. ## Conclusion Adopt Dust3D if you need low poly meshes with rigging and UVs produced inside one tool, and you are willing to build it from source with Qt 6 and qmake. Skip it if you need a mature sculpting or retopology workflow, or if you want a signed installer from a vendor. Verify first that your Qt install includes qtbase, qtsvg and qtmultimedia, that your compiler supports C++17, and that the exported GLB or FBX survives your engine's import step. ## FAQ ### Is Dust3D free? Yes. Dust3D is licensed under the MIT License, and the README links to the LICENSE file in the repository. Prebuilt binaries are published as release artifacts named Dust3D-win32-x86_64.zip, Dust3D-x86_64.AppImage and Dust3D.dmg. ### How do I use Dust3D? The README covers building and running rather than modeling steps. On macOS or Linux you change into the application directory, run qmake, then make; on Windows you open the .pro file in Qt Creator and click Run. For usage beyond that, the README points to dust3d.org for more information. ### Is Dust3D safe? The repository is not archived and the last push was on 2026-08-17, with releases 1.1.4 through 1.1.6 published in June 2026. The README documents the build from source and the release artifacts, so you can inspect the code and build it yourself rather than relying on a binary. ## Sources - [huxingyi/dust3d on GitHub](https://github.com/huxingyi/dust3d) - [License: MIT](https://github.com/huxingyi/dust3d/blob/master/LICENSE) - [Project website](https://dust3d.org/) - [README](https://github.com/huxingyi/dust3d/blob/master/README.md) - [Releases](https://github.com/huxingyi/dust3d/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/huxingyi-dust3d