Fabric-Project/Fabric: a Metal-bound node editor for creative coding on Apple platforms

The Quartz Composer-shaped hole Fabric is trying to fill

Quartz Composer was Apple's visual patching environment: you wired nodes together, hit run, and got interactive graphics without writing a renderer. Apple deprecated it, and the people who built pipelines on it have been migrating ever since. Fabric is an explicit attempt to rebuild that workflow on Metal. The README states the project is "inspired by Apple's deprecated Quartz Composer ecosystem, and its design philosophy," and the author, Anton Marini, writes in the FAQ that he is looking to build a community of developers who miss Quartz Composer's ease of use and its plugin ecosystem.

The target audience is narrower than "creative coders" as a whole. Fabric names three uses: a creative coding tool that requires little to no programming experience, a pro-user tool for producing reusable documents that can be loaded into the Fabric runtime and embedded in third-party applications, and a developer environment built on Satin for procedural high-fidelity rendering. Those are three different audiences sharing one file format. The second one is the interesting bet: a composition you build visually becomes an asset another app loads, which is the interoperability story Quartz Composer never fully delivered outside Apple's own tools.

How a Fabric document actually executes

The unit of work is a Node with Ports, and the README points to ARCHITECTURE.md for the execution model, describing it as covering "what a `Node` and a `Port` is, the types of data Fabric can generate and process, and how Fabric executes your compositions." The repository ships NODES.md as the catalogue of available and planned nodes, and GLOSSARY.md alongside it, which suggests the vocabulary is still being pinned down.

Rendering sits on Satin, a 3D engine written in Swift and C++ by Reza Ali, which the README credits as the foundation for Fabric's high-fidelity output. Image effects come from a licensed Metal port of the Lygia shader library by Patricio Gonzalez Vivo and contributors. On top of that stack Fabric documents physically based rendering, a scene graph, lighting and shadow casting, GPU compute, image-based lighting, 3D model loading, a material system, shader-based image processing and mixing, realtime shader editing with hot reloading, ML-based realtime segmentation and keypoint detection, and local LLM calling.

Two integration dependencies are worth noting because they constrain the plugin story: Syphon, for sharing frames between applications on macOS, and HapInAVFoundation, for Hap video codec playback through AVFoundation. Both are git submodules, which is why the build instructions insist on a recursive clone. The plugin architecture is described in PLUGINS.md, and the README frames custom nodes as the extension path.

Installing Fabric and running your first composition

There are two routes. For users, the README directs you to the Releases page for code signed app downloads. For developers, you build from source, and the submodules are not optional: Satin, Syphon and HapInAVFoundation are all dependencies. The README gives this clone form.

git clone --recurse-submodules https://github.com/Fabric-Project/Fabric.git

If you already cloned without them, the README gives the recovery command.

git submodule update --init --recursive

On macOS you then build two xcframeworks before opening the project. The scripts live in the scripts directory.

./scripts/build-syphon-xcframework.sh
./scripts/build-hapinavfoundation-xcframework.sh

After that, open Fabric.xcodeproj, make sure Fabric Editor is the selected target, and build and run. The README lists the requirements as macOS 15 or later and Xcode 15 or later, and carries a warning that Fabric is heavily under construction. Once the editor is up, the fastest way in is the Samples directory, which the README describes as a set of evolving tutorial and getting started compositions with a readme walkthrough you can build from. Before wiring anything yourself, read ARCHITECTURE.md, because the execution model is not something you can infer reliably from the canvas alone.

The macOS-only decision, and what it costs you

The README's own FAQ answers the cross-platform question with a flat no: Fabric is purpose built on Satin and aims at a best-in-class Apple platform experience using Metal. That is a deliberate trade, and it is the single largest constraint on adoption. If your team ships on Windows or Linux, or if you need a composition to run in a browser, Fabric is the wrong tool and no amount of node coverage will change that.

The second limitation is maturity. The README's requirements section carries a warning that the project is heavily under construction, and the release history supports that reading: Beta 1.0 landed on 2026-09-04, following Alpha-13 on 2026-04-02 and Alpha-11 on 2026-01-29. The last push to the repository was on 2026-09-14, so development is ongoing, but "ongoing" is not the same as "stable API." A composition format that is still being defined is a poor place to store work you cannot rebuild.

The third is documentation depth. The README delegates heavily: ARCHITECTURE.md for the execution model, NODES.md for the node catalogue, PLUGINS.md for extensions, ROADMAP.md for direction. The README itself does not document error handling, versioning of the document format, or what happens when a composition references a node that a target application does not have. If you plan to ship Fabric documents inside another app, that gap is the one to close first.

Fabric against Vuo and TouchDesigner

The README's FAQ addresses the obvious comparison directly, and the answer is a matter of taste rather than capability. The author writes that Vuo and TouchDesigner are incredible tools but "they do not think the way I think," and specifically that they do not expose the layers of abstraction he wants or provide the user experience he wants. That is an unusually candid framing: Fabric is not claiming to beat them on features.

The concrete difference is the stack. TouchDesigner is a mature commercial environment with its own GPU pipeline and a long track record in installation and live performance work, and it runs on Windows as well as macOS. Vuo is a macOS node-based environment that compiles compositions to native binaries. Fabric's distinction is that it is built on Satin and Metal, is BSD-3-Clause licensed, and exposes an SDK for loading a common interchange format into third-party applications. If your requirement is embedding a composition inside your own macOS app, that SDK is the reason to look at Fabric rather than the alternatives. If your requirement is a stable production tool with a decade of tutorials, the alternatives win on evidence alone.

Licence, plugins and the cost of keeping up

Fabric itself is BSD-3-Clause, which is permissive and places few conditions on redistribution beyond retaining the copyright notice and disclaimer. That covers the repository, not necessarily everything it links. The README states that Fabric includes a licensed Metal port of the Lygia shader library, and the word "licensed" matters: Lygia is a separate project by a different author, and its terms are not the same document as Fabric's LICENSE file. If you redistribute a build, check the licence of each bundled component rather than assuming the top-level BSD-3-Clause covers the whole binary. This is a description of what the repository says, not legal advice.

Upgrade cost is the practical concern. With Beta 1.0 arriving in September 2026 after two alphas earlier the same year, the document format and node set are still moving. Any composition you build now is a candidate for breakage at the next milestone. That is acceptable for prototyping and for internal tools where you control both ends. It is expensive if you have shipped Fabric documents to users who cannot rebuild them. Pinning to a specific release tag and re-testing compositions against the next one is the only way to know what a milestone actually changed, because the README does not describe a migration path between versions.

Editorial conclusion

Adopt Fabric if you are on macOS 15 or later and want Quartz Composer style patching with Metal-era rendering, ML segmentation, and an SDK for embedding documents in your own app. Do not adopt it if you need Windows or Linux, or if you need a stable, documented API surface today: the README warns it is heavily under construction, and the current milestone is Beta 1.0. Before committing, clone with --recurse-submodules, run the two xcframework build scripts, confirm the Fabric Editor target builds against Xcode 15, and read ARCHITECTURE.md and NODES.md to check whether the node you need already exists.

Frequently asked questions

Official sources

1. Fabric-Project/Fabric on GitHub
2. License: BSD-3-Clause
3. Project website
4. README
5. Releases