Amuse: one desktop app for local image, video, audio and text generation

One application across four media types

Amuse is described in a line as local AI image, video, audio and text. The feature list makes clear that this is one desktop application covering the whole media pipeline rather than a set of separate tools.

The features cover the editing and post-production side as much as the generation side. There is a Video Editor for generated or local content, Image and Video Upscale for static and moving media, Feature Extraction from images and video, Video Interpolation for frame rates and slow-motion, Image Inpaint to remove objects or fill areas, Advanced Image Editing with selection and masking tools, a Media Gallery for organization and management, and Lora and ControlNet support for output control.

Audio has its own pair of features: Voice Generation with Supertonic and Speech Recognition with Whisper. The text side is less about features and more about which models are wired in, and it is the pipeline list that carries the weight of the whole project.

The format support is the quiet capability that matters most for an evaluation. Safetensors, GGUF and ONNX support means the app can consume models in the three formats that dominate local inference, which is the difference between an app that works with the models you have and one that needs a specific conversion.

The primary language is C#, the licence is Apache-2.0, the default branch is master, and the last push was on 2026-10-16. The project is not archived, and the recent releases are frequent and named after what they add: v3.8.4 with FLUX.3 Klein 6B from 2026-10-16, v3.8.3 with Iris Image from 2026-10-11, and v3.8.2 with LLM Tool Calling Support from 2026-10-06.

The pipeline list, which is really the feature list

The most informative part of the README is the enumeration of supported pipelines, because for a local generation app the model coverage is the feature set.

The image pipelines are the largest group: Z-Image, Qwen, FLUX.1, FLUX.2, FLUX.3, Chroma, Kandinsky5, StableDiffusion-XL, StableDiffusion-3, Ernie Image, Anima, JoyAI Image, PRX-Pixel, Krea2, GLM Image, Ideogram 4, Boogu, Lens, LongCat, HiDream-O1, LLaDA Image and SenseNova U1.5.

The video pipelines are a shorter list: Wan 2.2, CogVideoX, Kandinsky5, SkyReels-V2, Helios, Motif, AnyFlow and MiniMax-H3. Kandinsky5 appears in both lists, which suggests a shared implementation rather than two separate ones.

The audio pipelines are ACE-Step XL, Whisper, Supertonic v3 and LongCat Audio, and the text pipelines are Qwen 3.0, 3.5, 3.6 and 3.8, and Gemma 4.0. The text list is short enough to notice the pattern: the Qwen series is versioned in the same numbering as the language models themselves, which tells you the app tracks upstream releases closely.

What this list means for an adopter is that the question is never whether the app supports a model in the abstract, it is whether the model you want is on the list, and whether the model you have in a given format will load. The LLM Tool Calling Support in the v3.8.2 release also suggests the text side is being wired up as an assistant rather than only as a completion endpoint.

The release names give a second signal. Naming a release after the model it adds, FLUX.3 Klein 6B, tells you that supporting a new model is the unit of work for the maintainer, and that the rate of model turnover is the pace of the project.

Three GPU backends, and why Vulkan matters

Amuse provides multiple GPU backends, allowing you to choose the best option for your hardware and operating system, and the three choices are CUDA, Vulkan and ONNX Runtime, which map onto the host projects in the repository tree.

CUDA is the Nvidia path. NVIDIA GPUs can use CUDA 13.0 for native GPU acceleration, and RTX-enabled cards are strongly recommended for the best generation performance, as they provide Tensor Cores specifically designed to accelerate AI workloads. Legacy architectures such as Pascal and Maxwell may work, but are not recommended for optimal performance. There is also a hard requirement: an NVIDIA driver version of 580.65 or later is required for CUDA 13.0 compatibility.

Vulkan is the cross-vendor option, and this is the part that widens the audience. Vulkan provides a cross-vendor GPU backend that can be used on compatible hardware without requiring CUDA or ROCm, which makes it particularly useful for GPUs and systems that do not have access to a supported CUDA or ROCm environment. The caveat is stated plainly: Vulkan support depends on the capabilities of the installed GPU and Vulkan driver.

So an AMD or Intel card, or an Nvidia card in an environment where ROCm is not an option, is not excluded from the project. It uses a different execution path with a different performance profile, and the README does not pretend otherwise.

The honest summary of the whole section is the note at the end: actual GPU compatibility and performance depend on the GPU model, driver version, operating system, and backend being used. There is no support matrix, so the practical approach for an evaluator is to check your own hardware against the three backend descriptions and expect to try the one that matches.

There is also a Windows-specific note: users may need to Run As Administrator during environment creation if environment setup fails. That is a hint that the environment setup step touches protected locations on Windows.

Building it: Visual Studio, .NET 10 and a solution file

Amuse is built on .NET 10 and is developed using Visual Studio, and the build instructions are correspondingly Windows and IDE oriented.

To build and run Amuse, the steps are: install Visual Studio 2026 with the .NET desktop development workload, clone the repository and open the .sln solution file in Visual Studio, allow Visual Studio to restore the required NuGet packages and dependencies, select the desired build configuration, either Debug or Release, and build the solution using Build then Build Solution or Ctrl+Shift+B. The resulting binaries are available in the project's configured build output directory, and you run Amuse.exe to start the application.

So there is no pip install and no npm install here. The runtime is a Windows desktop executable, and the build path is the Visual Studio one. That is a significant constraint for anyone evaluating the project on macOS or Linux, and the README does not offer a cross-platform route.

The solution structure in the tree explains the three backends. There is Amuse.App/, which is the desktop application itself, Amuse.Common/ for shared code, and three host projects: Amuse.Host.HuggingFace/, Amuse.Host.OnnxRuntime/ and Amuse.Host.StableDiffusionCpp/. That is one host per execution backend, each wrapping a different inference stack.

The attribution list confirms what the hosts are for. TensorStack is the author's own inference library and sits alongside Diffusers and Transformers from Hugging Face, which are the Python libraries that the Hugging Face host wraps, and StableDiffusion.cpp is the C++ implementation that the StableDiffusionCpp host wraps. The other dependencies, PdfPig for PDF parsing, Markdig for markdown, Serilog for logging, WebLookup and ColorCode, are the supporting libraries of a desktop application rather than of the inference layer.

The build also has a shared Directory.Build.props, which is where the version and common properties live across the projects, and a Scripts/ directory for the build helper scripts.

Licensing: Apache-2.0 for source, something else for the binaries

Amuse is licensed under the Apache License 2.0, and then there is a note that changes the picture for anyone distributing the application: compiled binaries are licensed under the Amuse 2.0 License due to the inclusion of bundled third-party software and dependencies, which may be subject to their own licensing requirements.

So the source and the shipped artefact have different terms, and the reason given is bundling. This is the common pattern for a desktop application that embeds inference runtimes: the code you can read is under a well known permissive licence, and the binary you download carries the combined obligations of everything packed inside it.

The distinction matters most for two audiences. For a user running the application locally, it changes nothing. For someone redistributing the binaries, for example in a managed environment or an appliance, the Apache-2.0 grant on the source is not the whole picture and the Amuse 2.0 License text governs what they pass on.

The attribution section lists the projects the project is made possible in part by, which is the practical inventory of what ends up in those binaries: PdfPig, Markdig, Serilog, WebLookup, ColorCode, TensorStack, Diffusers, Transformers and StableDiffusion.cpp. Reading that list tells you what the licence obligations have to cover, since it names the actual bundled components.

The project also carries a NOTICE-style separation between the code and the assets, with an Assets/ directory at the top level alongside the code, and the licence files are in the root. If you are considering redistribution, that is the set of files to read.

Editorial conclusion

Adopt Amuse if you want a single desktop application for local image, video, audio and text generation and your hardware is either an Nvidia card on a recent driver, or a card you can only reach through the Vulkan backend, since the three host projects mean you are not locked to one inference stack. Do not adopt it expecting a cross-platform install, because the build instructions are Visual Studio 2026 on .NET 10 and the result is a Windows executable, and do not redistribute the binaries assuming the Apache-2.0 source licence covers them, because the compiled binaries are under the separate Amuse 2.0 License. Before you commit, check that the specific model you want is in the pipeline list, confirm the GPU path you have is one of the three documented backends, and read the licence files for the bundled dependencies named in the attribution section.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. README
4. Releases
5. saddam213/AmuseAI on GitHub