# Fabric: version numbers are dates, and go.mod is the feature list

> Fabric is a Go framework that stores AI prompts as patterns organised by real-world task and runs them from a terminal or a REST server. The two things an adopter learns fastest are that its release numbers are timestamps rather than milestones, and that every supported model vendor is a dependency in go.mod, so each new backend arrives as its own patch release.

**danielmiessler/Fabric** — Fabric organizes AI prompts into a crowdsourced library of reusable patterns for solving specific problems, callable from the CLI or its REST API.

- Repository: https://github.com/danielmiessler/Fabric
- Website: https://danielmiessler.com/p/fabric-origin-story
- Stars: 44,108 · Forks: 4,287
- Language: Go
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/danielmiessler-fabric

## Three releases on one day, so the version number is a timestamp

The three most recent releases are v1.4.492 at 06:50 UTC, v1.4.493 at 18:04 UTC and v1.4.494 at 19:33 UTC, all on 2026-09-29, and the repository's last push is the same day. The README carries a personal note from the maintainer about development velocity, with a running list of recent releases going back to late 2025.

Read that as an upgrade policy rather than a curiosity. There is no minor-version boundary to plan around, no deprecation window, and nothing to upgrade to in the usual sense. You either track the tip, which means re-testing whenever you feel like it, or you pin a number that was chosen on a particular afternoon.

The version string still has one use. When a release note says a feature landed in a specific version, that number is how you find the change. But as a compatibility boundary it means nothing, and a changelog that lives inside the README rather than in a release feed means you are reading prose, not diffs.

The CHANGELOG.md at the root and the release pages are the places to look for a specific change. The version in your build tells you almost nothing about what is in it.

## go.mod is the honest feature list

The module is github.com/danielmiessler/fabric and it asks for Go 1.26.0:

```go
module github.com/danielmiessler/fabric

go 1.26.0
```

The dependency list is where the architecture shows itself, because every subsystem is a library someone else maintains.

The command line is cobra with go-flags. The REST server is gin, and the interactive documentation is swaggo, added in v1.4.350 as Swagger and OpenAPI served at /swagger/index.html. Storage is mattn/go-sqlite3, so patterns live in a local database file rather than a service. Translations are nicksnyder/go-i18n. Integrations include go-github for GitHub, go-readability for turning a web page into text, atotto/clipboard for the copy-to-clipboard path, go-git, yaml.v3, and samber/lo.

Then the model vendors, one SDK each: anthropic-sdk-go at v1.75.0, openai-go, the AWS SDK with bedrock and bedrockruntime, the Azure identity SDK, perplexity-go, ollama, and google.golang.org/api.

The consequence is a wide surface. Each entry is a vendor integration you now own operationally, an authentication path to configure, and a version to track when the vendor ships a breaking SDK change.

## New models arrive as their own patch release

The release notes are a catalogue of model support, and the pattern is consistent. v1.4.447 in April 2026 added Claude Opus 4.7, updating the Anthropic SDK to v1.37.0 and including 1M-token context window support. v1.4.334 in November 2025 added Claude Opus 4.5. v1.4.322 in the same month mentions Claude Sonnet 4.5 alongside a new pattern.

The manifest now pins anthropic-sdk-go at v1.75.0, so the SDK moved again after that release note. This is the part to internalise: in Fabric, a model name, an SDK version and a Fabric version move together, and they move in patch releases.

For a team that hard-codes a model name in a script or a saved pattern, that has a cost. When a model is renamed or retired upstream, your configuration does not fail loudly, it starts erroring at call time, and the fix is to upgrade Fabric and change the name. Pinning Fabric is therefore not a neutral act: it pins your model menu as a side effect.

If you keep long-lived scripts against it, record the Fabric version next to the model name in the same comment, because one of them will drift without the other.

## Backends multiply as plugins, and authentication splits in two

Since late 2025 the supported backends have arrived one plugin at a time, and the list is worth reading as a map of what people actually run.

v1.4.437 added OpenAI Codex as a backend using your existing OpenAI subscription. v1.4.417 added an Azure AI Gateway plugin that fronts several providers, AWS Bedrock, Azure OpenAI and Google Vertex AI, through a single Azure APIM gateway with shared subscription key authentication. The next day, v1.4.416 added Azure Entra ID authentication and pulled the shared Azure logic into a reusable azurecommon package. Earlier additions include Microsoft 365 Copilot for corporate data in v1.4.380, DigitalOcean GenAI in v1.4.378, GitHub Models in v1.4.331, Abacus as a Chat-LLM vendor in v1.4.338 and Z AI in v1.4.337.

Two observations. Enterprise backends arrive with their own authentication story rather than a shared one: a shared subscription key for the gateway path, Entra ID and MSAL for the identity path, and a corporate Microsoft 365 session for Copilot. Setting one up is a plugin, a credential and a subscription, and the README's own recommendation is a separate guide per integration.

The second is local models. ollama is a direct dependency, so running against a model on your own machine is part of the supported surface rather than an experiment.

## Setup is translated into ten languages, and locales fall back silently

Internationalisation reached the setup path in v1.4.356 in December 2025, which the notes describe as full i18n support for setup prompts across all ten languages with environment variable handling. The language list grew in stages: v1.4.309 brought English and Spanish, v1.4.311 added German, Persian, French, Italian, Japanese, Portuguese and Chinese, and v1.4.317 added Portuguese locale variants.

That last one is the interesting detail. v1.4.317 introduced BCP 47 locale normalisation with support for Brazilian Portuguese and European Portuguese, and with fallback chains when the exact locale is not available.

Fallback chains are the kind of feature that saves a user and hides a bug. A missing or misconfigured locale does not fail; it resolves to something nearby and the setup prompts appear in a language the user did not ask for. The same applies to the environment variable handling, which the project ties to the translated prompts, so a variable name that does not match a known key can leave you reading defaults.

If you script setup for users in several regions, verify the locale your environment produces rather than assuming the nearest match is the right one. The library doing the work is nicksnyder/go-i18n, and the repository also carries a Chinese translation of the README alongside the English one.

## Patterns are the unit, and the REST server is the durable interface

The premise is stated in the README's What and why section. AI does not have a capabilities problem, it has an integration problem, and Fabric's answer is to organise the fundamental unit of AI, the prompt itself, by real-world task. You create, collect and organise your most important solutions in one place, and then either use Fabric as the command line interface or take the patterns into whatever tool you already use.

That second option is why the REST server matters. The notes for v1.4.350 added interactive API documentation with a Swagger and OpenAPI interface at /swagger/index.html, and the dependencies confirm a gin server with swaggo generating it. A script that talks to that server is insulated from changes in the terminal interface, and bound to the server instead, which is a trade worth making deliberately rather than by accident.

The repository structure follows the same split. Patterns and their data live under data/, the terminal entry points under cmd/, internals under internal/, the web pieces under web/, and shell completions under completions/. The README's own navigation lists the sections you need: Installation, Usage, the REST API, Examples, Just Use the Patterns, Custom Patterns and Helper Apps, and the docs folder is where the internals are explained in depth.

## A Go module, a Nix flake, a devcontainer and GoReleaser

There is no single install line in this repository worth repeating here, because the project supports several shapes of installation and describes them in its Installation section rather than at the top of the file. What the tree does tell you is what each shape needs.

The module declares go 1.26.0, so the build floor is recent. There is a flake.nix with a flake.lock, which makes a Nix-based environment a supported path rather than an experiment, and a .envrc, which is the direnv convention for loading variables when you enter the directory. A .devcontainer/ directory means there is a container-based development environment, and .goreleaser.yaml is how the binaries are produced. A .dockerignore sits next to them for anyone building an image, and completions/ holds the shell completion material.

Credentials come from the environment, not from a config file in the repository: godotenv is a dependency and the setup prompts are described as handling environment variables intelligently. For a headless or container install, that means the variables must exist before the first run, and the setup path is where they are named.

For the internals, the README points to the docs folder and to a DeepWiki page, both of which exist because the code changes several times a week.

## Conclusion

Adopt Fabric if you want a shared library of prompt patterns that works from a terminal, from a script or over HTTP, and if you are willing to track a project that ships several releases a week. Do not adopt it by pinning a version and forgetting it, because model support and vendor plugins arrive as patch releases and a stale pin quietly loses the backends you added it for. Verify first by checking which model vendors the build in front of you actually links, then by reading the docs folder rather than the changelog, and by putting your credentials in the environment before the first run.

## FAQ

### What is Fabric and what problem does it solve?

Fabric is an open-source framework for augmenting people with AI, built around a modular system of crowdsourced prompts. It organises prompts by real-world task so you can create, collect and reuse your own solutions, and it frames the problem as integration rather than capability.

### How do I install Fabric?

Installation is covered in its own section of the README. The repository is a Go module requiring Go 1.26.0, and it ships a Nix flake with a lock file, a .envrc for direnv, a .devcontainer directory and a .goreleaser.yaml for the release binaries.

### Which AI backends does Fabric support?

Recent releases added OpenAI Codex using your own subscription, an Azure AI Gateway plugin fronting AWS Bedrock, Azure OpenAI and Google Vertex AI, Azure Entra ID authentication, Microsoft 365 Copilot, DigitalOcean GenAI, GitHub Models, Abacus and Z AI. Ollama is a direct dependency, so local models are also supported.

### Does Fabric have a REST API?

Yes. Release v1.4.350 added a Swagger and OpenAPI interface at /swagger/index.html with documentation for the endpoints. The module depends on gin for the server and on swaggo for the generated documentation, and the README links a REST API section for usage.

## Sources

- [Official documentation](https://danielmiessler.com/p/fabric-origin-story)
- [Official README](https://github.com/danielmiessler/Fabric#readme)
- [Project repository](https://github.com/danielmiessler/Fabric)
- [Release notes](https://github.com/danielmiessler/Fabric/releases)

---

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