AutoRemesher: automatic quad remeshing from the command line

What AutoRemesher actually solves for retopology work

Retopology is the step where a dense, sculpted or scanned mesh gets rebuilt as a clean quad surface that a rigger, animator or UV artist can work with. Doing it by hand is slow and repetitive. AutoRemesher targets that specific job: it takes a high-polygon input mesh and produces quad-based topology automatically. The README describes it as a cross-platform automatic quad remeshing tool, and the repository topics list quadremesh and retopology, so the scope is narrow by design. It is not a sculpting tool, not a mesh repair suite, and not a renderer. The intended user is someone who already has a dense mesh and needs a lower-polygon quad version of it, either interactively through the Qt GUI or in a batch pipeline through the CLI. The project is written in C++ and builds on Geogram, libigl and isotropicremesher, plus other libraries listed in ACKNOWLEDGEMENTS.html. That stack choice matters: it means the quad extraction is not a black box the author wrote from scratch, and it also means the build has a real dependency surface.

The pipeline: high-poly input, quad output, a report file

The mechanism visible from the README is a two-front application. The GUI is a Qt 5.15.2 desktop program, and the same binary exposes a CLI mode for headless processing. In CLI mode you pass an input mesh, an output mesh, a report path, and a set of numeric parameters. The parameters named in the README are --target-quads, --edge-scaling, --sharp-edge, --smooth-normal, --adaptivity and --anisotropy. Each one shapes the remeshing result rather than the input: target quads sets the quad budget, edge scaling influences edge length, sharp edge takes an angle threshold, and adaptivity and anisotropy control how much the quad density is allowed to vary across the surface. The report file is the part worth noting. Because the output is generated rather than authored, having a written report alongside the mesh gives you something to diff between runs. The README does not describe the report's contents, so treat it as an artifact to inspect rather than a documented contract. The third-party layer is where the geometric work happens: Geogram and libigl supply the mesh processing primitives, and isotropicremesher is the author's own remeshing library. AutoRemesher is best understood as the orchestration and UI layer over those libraries, which is why the build instructions are about Qt and TBB rather than about algorithm configuration.

Installing AutoRemesher and running a first CLI remesh

There are two paths. The quick path is a release download: Windows gets a zip containing autoremesher.exe, macOS gets a dmg, and Linux gets an AppImage. The README notes that on macOS the first launch is blocked by Gatekeeper with a message about integrity, and that you allow it under System Preferences, Security and Privacy, General. On Linux the AppImage needs the executable bit before it will run.

chmod a+x ./autoremesher-<version>.AppImage
./autoremesher-<version>.AppImage

The build path is for development. On Ubuntu or Debian the README installs Qt and the build tools, then TBB and OpenGL, then builds with qmake and make.

sudo apt install build-essential qt5-qmake qtbase5-dev qttools5-dev-tools libqt5svg5-dev libqt5multimedia5-dev
sudo apt install libtbb-dev libgl1-mesa-dev
git clone https://github.com/huxingyi/autoremesher.git
cd autoremesher
qmake
make -j$(nproc)

Fedora users get a single dnf line instead: gcc-c++, qt5-qtbase-devel, qt5-qttools-devel, tbb-devel and mesa-libGL-devel. Windows with Visual Studio 2022 requires CMake specifically to build the bundled TBB from source before qmake runs, and the README points at the msvc2019_64 Qt archive. An MSYS2 and MinGW-w64 route builds against Qt 6 instead, and the README warns that the binary must be run from the MINGW64 shell or have its DLLs bundled with windeployqt-qt6. macOS uses Homebrew for qt@5, tbb and cmake, then qmake CONFIG+=sdk_no_version_check and make.

Once you have a binary, the README's quick test uses a mesh from the common-3d-test-models repository and drives the CLI with every parameter spelled out.

./autoremesher \
    --input armadillo.obj \
    --output remeshed.obj \
    --report remeshed_report.txt \
    --target-quads 50000 \
    --edge-scaling 1.0 \
    --sharp-edge 90.0 \
    --smooth-normal 0.0 \
    --adaptivity 1.0 \
    --anisotropy 1.0

You should end up with remeshed.obj and remeshed_report.txt in the working directory. The README gives no defaults for these flags, so start from the values above and change one at a time.

Where AutoRemesher is the wrong tool

The most common mismatch is expecting a Blender addon. AutoRemesher is a standalone application with its own Qt interface and its own CLI. The README describes no Blender integration, no addon package, and no Python API. If your workflow lives inside Blender and you want a remesh button in the UI, this project does not offer that, and the related searches around a Blender addon are not answered by anything in the repository. The second mismatch is automation without versioning discipline. The CLI is scriptable, but the README does not document rollback, does not describe how parameters interact, and does not specify defaults for any flag. A pipeline that reruns remeshing on every asset build will produce different meshes when you change a parameter, and there is no documented way to pin the algorithm behaviour beyond pinning the binary itself. Third, the build requirements are not trivial: Qt 5.15.2, TBB, and on Windows a CMake-driven TBB build from bundled source. If you cannot install Qt 5.15.2 in your environment, the source route is closed and you are limited to release artifacts. Finally, the project is a remesher, not a mesh doctor. Nothing in the README suggests it repairs non-manifold input, fills holes, or fixes inverted normals before remeshing. Garbage in, garbage out applies, and the report file is your only signal about what happened.

AutoRemesher compared with the commercial Quad Remesher route

The obvious alternative is Quad Remesher, the commercial auto-retopology product that many people reach for first. The difference in approach is integration and licensing rather than algorithm. Quad Remesher is distributed as a plugin for host applications, which is why so many searches pair it with Blender, and it is a paid product. AutoRemesher is an MIT-licensed standalone C++ application that you download as a zip, dmg or AppImage, or compile yourself against Qt and TBB. If your constraint is working inside a host application with a vendor-supported installer, the commercial route fits better. If your constraint is licence terms, a headless binary you can call from a build script, or the ability to read and modify the source, AutoRemesher is the one that gives you that. The trade-off is real in both directions: AutoRemesher asks more of you at setup time and documents less about its parameters, while the commercial product asks for money and keeps the algorithm closed. Neither is a drop-in replacement for the other, because the delivery model is the whole difference.

Maintenance, licence and what an upgrade costs you

The repository is not archived, and the last push was on 2026-09-03. Releases are recent: 1.0.0 on 2026-07-06, 1.1.0 on 2026-08-16, and 1.2.0 on 2026-08-23. That release cadence over roughly seven weeks suggests active work, and the version jumps are minor rather than patch-level, so behaviour changes between them are plausible. The practical upgrade cost is the build. Because the project builds with qmake and a .pro file rather than CMake for the application itself, and because Qt is pinned at 5.15.2 in the README, moving to a newer Qt is not a documented path. The MSYS2 instructions do use Qt 6, so a Qt 6 build is at least known to the author, but the README presents it as an alternative toolchain rather than the default. If you ship a binary, you carry the TBB and Qt runtime dependencies with it. On licence: the project is MIT, which is permissive and imposes few obligations beyond keeping the copyright notice. That covers AutoRemesher's own code. It does not automatically cover the bundled third-party libraries, and ACKNOWLEDGEMENTS.html is the file the README points to for the full list. If you redistribute a build, read that file and the individual library licences rather than assuming MIT applies end to end. This is not legal advice; it is a pointer to where the answer lives.

Editorial conclusion

Adopt AutoRemesher if you want a standalone, MIT-licensed quad remesher you can drive from a shell script, and if you are willing to build it against Qt 5.15.2 and TBB or run one of the release archives. Skip it if you need a Blender addon, a Windows-only commercial retopology suite, or a tool with documented rollback and versioning guarantees. Before committing, verify the release artifact for your platform actually launches, then run one CLI pass on a mesh you already know well and compare the report file against your expectations.

Frequently asked questions

Official sources

1. huxingyi/autoremesher on GitHub
2. License: MIT
3. Project website
4. README
5. Releases