# Fabric Python Widgets: X11 and Wayland Development

> Fabric is a Python framework for desktop widgets on Linux, with support for X11 and Wayland. Its signal-oriented API targets Linux desktop customization, although the listed releases remain pre-alpha and the README does not document installation commands.

**Fabric-Development/fabric** — The next-generation framework for building desktop widgets using Python

- Repository: https://github.com/Fabric-Development/fabric
- Website: https://wiki.ffpy.org
- Stars: 1,394 · Forks: 46
- Language: Python
- License: AGPL-3.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/fabric-development-fabric

## Fabric's Linux Widget Use Case

Fabric addresses a narrow but practical problem in Linux desktop customization: building small graphical widgets without assembling every piece of GTK behavior through shell scripts or repeated polling loops. The intended audience is visible in the repository itself. Example directories cover bars, side panels, launchers, notifications, Bluetooth status, an icon browser, animated graphics and general desktop widgets. These are interface elements for an already running Linux session, not complete application suites with conventional window navigation, forms or business workflows.

The framework is presented as a desktop widget system customizable with Python. That distinction matters because Python can be used for more than drawing controls. A widget can also use Python modules for data acquisition, formatting and application control. The README highlights access to other Python modules as a feature, while `psutil` appears both in `requirements.txt` and under the `system-status` optional dependency. That dependency choice places process or system-status collection within Fabric's intended use cases.

The project description in `pyproject.toml` narrows the platform further by calling Fabric a framework for system widgets on Nix systems. The README also states support for both X11 and Wayland, and repository topics include `gtk`, `gtk3`, `x11` and `wayland`. Together, these sources point to Linux-oriented GTK work rather than a cross-platform UI framework. They do not establish support for Windows or macOS, and Fabric should not be presented as a portable replacement for Electron, Qt or native mobile UI toolkits.

Fabric is therefore best understood as a Python layer for composable desktop widgets. It is aimed at users who want direct control over a panel, status display, launcher or similar Linux interface element. Its advantage in that setting is access to Python, not an independently documented rendering model or production readiness guarantee.

## GTK, PyGObject and the Signal-Oriented Model

The dependency and topic metadata identify GTK and PyGObject as the foundation. `PyGObject==3.50.0` is pinned in both `pyproject.toml` and `setup.py`, while `pycairo` provides the Cairo dependency. GTK 3 is explicitly represented by the `gtk3` repository topic. Fabric can consequently be understood as a higher-level Python framework around the GTK object model, not as a separate widget renderer.

The README states a goal of providing a “high-level, signal-based workflow” without polling or Bash scripting for basic tasks. Signals in this context connect events or state changes to widget behavior, allowing a widget to react when something changes rather than repeatedly asking whether a condition has become true. That approach fits desktop components such as status indicators, where continuous refresh loops would waste work and could make many small widgets more expensive than necessary.

The available repository information does not expose Fabric's complete signal definitions, event flow or scheduling implementation. It also does not state whether Fabric owns application lifecycles, how it coordinates many widgets, or whether signal updates occur on the GTK main loop. The `run-widget.nix` file and examples indicate that individual widgets are real launchable artifacts, but their contents are not included here. A detailed claim about internal concurrency or update ordering would therefore go beyond the documentation.

The framework still offers a clear architectural boundary. GTK supplies the Linux widget foundation, PyGObject supplies the Python binding, Cairo is available for drawing, and Fabric supplies the higher-level widget conventions. Python code remains available for logic that would otherwise be divided between GUI callbacks and external shell utilities. The exact integration API must be confirmed in the wiki before committing a production widget design.

## Fabric Installation and First Launch

The README does not document an installation command, launch command, executable name or configuration procedure. It directs users to the wiki at `https://wiki.ffpy.org`, while the repository contains `PKGBUILD`, `default.nix`, `flake.nix`, `run-widget.nix` and `setup.py`. Those files show packaging and run support, but without their contents there is no verified command that can be copied here safely.

The declared Python requirement is version 3.11 or later. The core installation metadata names these dependencies:

```toml
dependencies = ["click", "loguru", "pycairo", "PyGObject==3.50.0"]
requires-python = ">=3.11"
```

This tells an engineer what packaging metadata declares, not how the native GTK dependencies should be installed. On Nix systems, `flake.nix`, `default.nix` and `run-widget.nix` are relevant project-specific files to inspect. Outside Nix, the project may be installable through `setup.py` or `pyproject.toml`, but the README does not explicitly confirm a supported installation route or package-manager command.

A first real use should begin with one of the repository's focused examples, such as `examples/desktop-widget/` or `examples/bar/`, rather than an empty application scaffold. The wiki should supply the exact invocation for that example. Readers should verify that the selected Fabric version matches `pyproject.toml` or the release they are packaging, and that the system provides a compatible PyGObject and GTK 3 stack. No command is invented here because the README does not state one.

## Example Scope Versus a General GUI Framework

The examples directory gives Fabric a useful scope indicator. `examples/app-launcher/` and `examples/icon-browser/` involve launching or selecting programs, while `examples/bluetooth-widget/`, `examples/notifications/` and `examples/system-status` concerns imply desktop status presentation. `examples/animated-circular-scale-widget/` demonstrates a rendering-oriented component, and `examples/side-panel/` suggests a persistent panel rather than a modal dialog.

These categories are different from those normally served by a full application framework. Fabric's metadata names GTK, bars, panels and docks as keywords, and the repository topics emphasize widgets and status bars. The documentation does not describe a scene graph, form designer, data-binding system, navigation stack, accessibility-testing suite or deployment tool for packaged desktop applications. Those omissions do not prove that every such feature is absent, but they mean the documentation cannot support claims about them.

Fabric can also appear in a larger Linux desktop setup rather than serve as the only interface framework. A user might combine a Python widget with external status tools or use it as one layer of a shell configuration. The README does not prescribe a required component stack, so integrations should be designed from the documented Python and GTK capabilities rather than assumed to follow a particular distribution format.

The repository's visual examples include links to external shell projects. Those links demonstrate possible desktop compositions, but they are not maintained as part of Fabric itself. Compatibility between Fabric releases and those shells cannot be inferred from their presence in the README.

## Pre-Alpha Releases and Dependency Boundaries

The release history places this project before stable adoption. The listed releases are `v0.0.1`, `v0.0.2` and `v0.0.3-pre-alpha`, with the pre-alpha release dated 2026-09-01. The package metadata currently reports version `0.0.2`, which means a source checkout and a released distribution may not represent the same point in the project.

The exact version distinction is operationally significant because `PyGObject==3.50.0` is pinned. Native desktop dependencies can also vary with the Linux distribution, GTK libraries, Cairo and the display server. The repository includes Nix-related files, and its description specifically references Nix systems. A Python package declaration alone does not guarantee that every GTK dependency is present on a generic Linux installation.

The repository is not archived, and the last push was on 2026-09-26. That indicates repository activity, but it does not change the pre-alpha label or establish a stable compatibility policy. Upgrade planning should therefore track both Fabric and the pinned PyGObject version. Changes to GTK bindings, Python version requirements or packaging files can affect existing widgets.

The AGPL-3.0 license also needs consideration when Fabric code is incorporated into a distributed desktop setup or offered as a network service. The repository identifies AGPL-3.0, but this review does not provide legal advice. License obligations should be reviewed for the exact distribution and hosting model rather than inferred from the framework's open source status.

## Raw GTK and PyGObject Instead of Fabric

The clearest alternative is to build the widget directly with GTK and PyGObject. This is not a different product with a similar widget list. It is a lower-level approach using the same broad graphics foundation that appears in Fabric's dependencies.

Direct GTK development gives the engineer explicit control over widgets, signals, drawing and lifecycle. It also avoids depending on Fabric's pre-alpha API and version compatibility. The trade-off is more framework assembly: the developer must manage GTK conventions, Python binding details and any higher-level structure that Fabric would provide. For a small isolated widget, that overhead may be reasonable. For a larger collection of related widgets, reducing repetition can be the reason to choose Fabric.

Another practical difference is release maturity. Fabric advertises a high-level Python workflow and includes multiple example categories, while the release list includes a version explicitly marked pre-alpha. A direct GTK implementation can use the underlying toolkit directly, but that does not remove the need to manage native dependencies or desktop compatibility.

Fabric is the better candidate when the desired result is a collection of Python-defined Linux widgets and the team accepts an early framework. Direct GTK is safer when exact control, established binding behavior or independence from Fabric's release cadence matters more than a higher-level API.

## Conclusion

Fabric fits Linux users who want to build status bars, panels and desktop widgets with Python while retaining access to the wider Python ecosystem. It is a poor fit for developers requiring a documented stable release process, a conventional GUI application framework, or platform support outside the Linux widget use cases named by the project. Before adoption, verify the exact version being installed, the GTK stack on the target system, X11 or Wayland behavior on that desktop, and whether the signal APIs needed by the widget are complete enough for production use.

## FAQ

### What is Fabric-Development/fabric used for?

Fabric is a Python framework for creating customizable desktop widgets on Linux. The repository examples include bars, side panels, launchers, notifications, Bluetooth widgets and system-status displays.

### Does Fabric support Wayland and X11?

The README states that Fabric supports both X11 and Wayland. Its topics also include `x11`, `wayland`, `gtk` and `gtk3`, while `pyproject.toml` declares a PyGObject dependency.

### How do I install Fabric-Development/fabric?

The README does not give an installation command and directs users to the project wiki. The repository contains `pyproject.toml`, `setup.py`, `PKGBUILD`, `flake.nix` and `run-widget.nix`, but the README excerpt does not state a verified installation procedure.

## Sources

- [Fabric-Development/fabric on GitHub](https://github.com/Fabric-Development/fabric)
- [License: AGPL-3.0](https://github.com/Fabric-Development/fabric/blob/main/LICENSE)
- [Project website](https://wiki.ffpy.org)
- [README](https://github.com/Fabric-Development/fabric/blob/main/README.md)
- [Releases](https://github.com/Fabric-Development/fabric/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/fabric-development-fabric