Nibia's maintainers claim their released v0.7.0-alpha Fabric pools CPU and RAM across trusted-LAN machines via partitioned GGUF execution, running models up to ~30B that exceed any single node's memory; independent multi-node replication and real usage decide whether distributed CPU/RAM inference is practical rather than merely released.

state: corroboratedheat: lowuncertainty: mediumconvergesscott: highlocal-inference distributed-inference open-sourceNibia AI

What is this?

Nibia Fabric v0.7.0-alpha is an open-source (Apache-2.0) distributed compute system from Nibia AI (org of Abraham D. Lopez / HN user 'abelop') that partitions GGUF model execution across multiple machines on a trusted LAN, pooling their aggregate CPU and RAM so models larger than any single node's memory can run. The GitHub release provides binaries, architecture docs, and a validation matrix covering Qwen3 30B-A3B, GPT-OSS 20B, and Gemma 3 27B. An independent Reddit user has since demonstrated a 120B model running across six heterogeneous devices (laptop, mini PC, Macs, Android), corroborating the core claim. The snippets confirm the release artifacts and partitioning approach; performance numbers (tokens/sec) are absent from the supplied material, and the trusted-LAN security model constrains deployment scope.

Why it matters to Scott

Nibia Fabric independently arrives at distributed CPU/RAM pooling via partitioned GGUF execution — a new axis for Scott's hardware-aware local inference substrate (gamepc/Ollama) that extends model capacity beyond single-node GPU memory. The trusted-LAN security model aligns with his single-tenant appliance and padded-cell architectures. Independent replication (120B across 6 heterogeneous devices) moves this beyond claim into demonstrated practice, directly bearing on how he could expand his local inference fleet without additional GPUs.

dev:technology.ollamadev:project.gamepcdev:concept.hardware-aware-local-inferencedev:concept.software-defined-heterogeneous-core-schedulingwork:project.chessbrain-netradar:exo-heterogeneous-device-inferenceradar:cascadia-distributed-intel-inferenceradar:lumabri-peer-to-peer-moe-inferenceradar:cascadia-laptop-distributed-inferenceradar:swarmllm-browser-distributed-inference

queries asked of Scott's wikis

distributed CPU inference GGUF partitioning
local inference hardware-aware multi-node RAM pooling
trusted LAN security model distributed inference
open source distributed inference fabric alpha
agent memory RAG multi-node CPU inference
model sovereignty local inference distributed

Measured heat

now 0 pts/hpeak 8 pts/hcomments 0/hpeers p14momentum: steady3 platformsage 362h

points/hour across evidence · reading as of 2026-10-12 02:59:37.977291+11:00 · deterministic, not a model opinion

How the heat travelled

09-26 14:00	⭐ origin echo-reconstructed	The repo is the primary artifact the Show HN announces — README: "NIBIA Fabric — Turn everyday computers into a shared AI compute cluster. O nibia-ai (NIBIA; org of Abraham D. Lopez, HN user "abelop") on github (echo) · attributed from hn.story.49882129	—
09-28 18:16	first on hacker news · published · +52.3h	Show HN: Nibia Fabric – Turn everyday computers into a shared AI compute cluster abelop	—
10-08 15:44	first on r/LocalLLaMA · published · +289.7h	Ran a 120B model across 6 computing devices that had no business running it! Medicine_Blogscanner	—
09-28 18:16	amplified on hacker news	hn.story.49882129 abelop	peak 1 · 3 comments · 35% of case engagement
10-08 15:44	amplified on r/LocalLLaMA 👑	reddit.post.1x0ubuc Medicine_Blogscanner	peak 3 · 10 comments · 65% of case engagement
09-28 18:21	our radar first saw it · +52.4h	discovery anchor: hn.story.49882129	—

pace: p52 vs 1032 stories at the 336h mark (now 362h old) — ahead of crowdstrike-safemind-security-agents (1.1x), behind agentdrive-persistent-shared-storage (0.9x)

Evidence (3) — ⭐ canonical anchor

source	object	author	score	comments
🟧 hn	Show HN: Nibia Fabric – Turn everyday computers into a shared AI compute cluster Retrieved article excerpt Open article · Retrieved 2026-09-28T18:37:04.354844+00:00 # NIBIA Fabric — Turn everyday computers into a shared AI compute cluster. Open-source distributed LLM inference across Mac, Windows, and Linux using aggregate CPU and system memory (RAM). [Nibia](https://github.com/nibia-ai/fabric/blob/main/docs/assets/nibia-logo.png) NIBIA Fabric is the open-source distributed compute core of NIBIA. This Experimental Alpha is a CPU-first local AI compute fabric that coordinates computers on the same trusted LAN and partitions GGUF model execution across the fabric, allowing larger models to use the aggregate CPU and RAM capacity of multiple nodes instead of depending on a single machine. > Small models stay local. Larger models can expand across the fabric when they need more memory. Release: v0.7.0 Experimental Alpha CLI version: v0.7.0-alpha Wire protocol: 2 License: Apache-2.0 ## Download NIBIA Fabric v0.7.0 Experimental Alpha is available as prebuilt binaries. Choose the archive for your operating system: \| Platform \| Download \| \| --- \| --- \| \| macOS Apple Silicon \| [Download macOS arm64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-macos-arm64.zip) \| \| Linux x86-64 \| [Download Linux amd64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-linux-amd64.zip) \| \| Windows x64 \| [Download Windows amd64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-windows-amd64.zip) \| \| SHA-256 checksums \| [Download checksum file](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/NIBIA_v0.7.0-alpha_SHA256SUMS.txt) \| Verify the SHA-256 checksum before installation. > GitHub also generates automatic Source code (zip) and Source code (tar.gz) > archives for every release. These are source snapshots, not the prebuilt NIBIA > packages intended for normal installation. Use the platform downloads above. After downloading, follow the [Quickstart](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) to install NIBIA, configure the Primary Node, and pair additional Worker Nodes. See the complete [v0.7.0 Experimental Alpha release](https://github.com/nibia-ai/fabric/releases/tag/v0.7.0-alpha). ## Supported release platforms Prebuilt binaries for this Experimental Alpha are provided for: - macOS arm64 — Apple Silicon - Linux amd64 — x86-64 - Windows amd64 — x64 Any supported desktop platform can be the Primary Node. Primary is a Fabric role, not an OS-specific tier: it is the node running the Controller, Coordinator, Agent, CLI, and local compute for that Simple Mode session. 32-bit operating systems and CPU architectures are not supported. ## Why NIBIA Fabric Modern local AI is often limited by the memory and compute available on one computer. NIBIA Fabric uses hardware you already have around you and turns it into one coordinated inference fabric. - Expand model capacity beyond one machine. Use safe RAM capacity from multiple computers for models that do not fit comfortably on the Primary alone. - Use heterogeneous everyday hardware. Mix supported Mac, Windows, and Linux nodes on the same fabric. - Activate only what is needed. Minimum Safe Fabric selects the smallest fresh worker subset that can satisfy the safe execution plan. - Keep the serving surface local by default. The Web UI and OpenAI-compatible API bind to localhost on the Primary in this alpha. - Avoid heavy end-user toolchains. Prebuilt NIBIA binaries manage a pinned, verified, precompiled llama.cpp runtime. ## How it works In the default Simple Mode, one supported computer is chosen as the Primary Node and runs the Controller, Coordinator, Agent, CLI, and local compute. Additional computers run persistent NIBIA Agents. macOS, Linux, and Windows are peers at the role level; the reference lab often uses a Mac as Primary, but the architecture does not require it. Remote llama.cpp RPC workers and secure relays are activated only when a workload needs them. ``` trusted LAN Primary Node Worker Nodes ┌──────────────────────────┐ ┌──────────────────────┐ │ Controller + Coordinator │◄──────►│ NIBIA Agent │ │ Agent + CLI │ mTLS │ on-demand RPC worker │ │ local CPU / Metal + RAM │ │ CPU + RAM │ │ GGUF model file │ └──────────────────────┘ │ localhost API / Web UI │ ┌──────────────────────┐ └──────────────────────────┘◄──────►│ NIBIA Agent │ │ on-demand RPC worker │ │ CPU + RAM │ └──────────────────────┘ ``` Workers do not need their own copy of the GGUF. NIBIA Fabric does not create a physical shared-memory address space; it makes independent node memory useful through distributed runtime placement and model partitioning. ## Run once or serve persistently NIBIA exposes two primary inference lifecycles: - `nibia run` — load the model, execute one prompt (or an explicitly requested terminal session), print the response, clean up the workload, and exit. Use it for terminal inference, scripts, and benchmarks. - `nibia serve` — load the model once and keep it resident for the built-in Web UI and local OpenAI-compatible API until `Ctrl+C`. Use it for interactive use and repeated requests. Example persistent server: ``` nibia serve \ --model ~/Models/model.gguf \ --ctx 4096 \ --port 8081 \ --controller http://127.0.0.1:8080 ``` The context value is explicit because supported/useful context varies by model and workload. `--port` and `--controller` remain configurable; SERVE itself stays loopback-only by default in this Experimental Alpha. ## What works today - Persistent NIBIA Agents with on-demand llama.cpp RPC workers. - Minimum Safe Fabric / Lazy Worker Activation with adaptive per-node memory reserve. - CPU execution on Linux/Windows and Apple Silicon Metal execution on macOS, with remote capacity expansion. - TLS 1.3 mTLS Agent control traffic and authenticated reverse RPC relay after pairing. - Raw llama.cpp RPC kept loopback-only on workers. - Pinned, SHA-256-verified managed llama.cpp runtime (`b10902`, commit `df03399`). - Persistent worker-local RPC tensor cache. - Local built-in llama.cpp Web UI and OpenAI-compatible API. - Bounded SERVE recovery after temporary selected-Agent loss. - Workload-scoped Power Guard on macOS, Linux, and Windows. ## Get started The release is prebuilt-first. Normal users do not need Go, Python, CMake, Visual Studio Build Tools, Homebrew, or a local llama.cpp source build. The [Quickstart](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) walks through the complete first-run path: 1. download and verify the release archive; 2. install NIBIA on each node; 3. create the Primary and pair Worker Nodes; 4. validate the fabric; 5. download a GGUF model to the Primary; 6. serve the model and open the built-in Web UI or local API. Start here: [QUICKSTART.md](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) ## Validated release coverage Physical validation for this Experimental Alpha includes: - Qwen3 4B Q4\_K\_M - Qwen3 14B Q6\_K - Qwen3 30B-A3B Q4\_K\_M — primary exhaustive release-validation workload - GPT-OSS 20B MXFP4 - Gemma 3 27B IT Q4\_K\_M The release also includes measured Wi-Fi vs Gigabit Ethernet testing, three-node wired execution, tensor-cache reuse testing, multiple context-size tests, lifecycle/recovery testing, and optional-client validation. See [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) for the validation matrix and [docs/BENCHMARKING.md](https://github.com/nibia-ai/fabric/blob/main/docs/BENCHMARKING.md) for measured methodology and results. Measurements are reference data, not guaranteed performance. ## Built-in UI and validated external clients The default interactive interface is the llama.cpp Web UI served locally by NIBIA Fabric. NIBIA Fabric also exposes a local OpenAI-compatible API. Optional external clients physically validated in documented release test modes include: - [Open WebUI](https://github.com/open-webui/open-webui) - [OpenClaw](https://github.com/openclaw/openclaw) They are independent projects and are not required NIBIA Fabric dependencies. See [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) for the tested modes. ## Security defaults NIBIA Fabric v0.7.0-alpha is intended for a trusted local network. - SERVE binds to localhost by default. - Controller administrative operations are localhost-only. - Initial pairing uses a short-lived trusted-LAN bootstrap code. - After pairing, Agents authenticate to the Controller with TLS 1.3 mTLS. - Raw llama.cpp RPC is not exposed directly on the LAN. - Managed llama.cpp downloads are pinned and SHA-256 verified before execution. See [docs/SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/docs/SECURITY.md) and [SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/SECURITY.md). ## Runtime and ecosystem NIBIA Fabric uses or interoperates with independent upstream projects that retain their own licenses and project identities: - [llama.cpp](https://github.com/ggml-org/llama.cpp) — MIT-licensed upstream project; pinned managed inference runtime, Web UI/server, GGUF execution, and RPC backend used by this release. - [Open WebUI](https://github.com/open-webui/open-webui) — separately licensed optional external UI; not bundled with NIBIA Fabric. - [OpenClaw](https://github.com/openclaw/openclaw) — MIT-licensed optional external client/agent integration; not bundled with NIBIA Fabric. NIBIA Fabric itself is licensed under Apache-2.0. Third-party projects retain their own upstream license terms. See [NOTICE](https://github.com/nibia-ai/fabric/blob/main/NOTICE) and [docs/DEPENDENCIES.md](https://github.com/nibia-ai/fabric/blob/main/docs/DEPENDENCIES.md). ## Documentation \| Document \| Purpose \| \| --- \| --- \| \| [QUICKSTART.md](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) \| Install, pair nodes, download a model, and serve it \| \| [docs/CLI.md](https://github.com/nibia-ai/fabric/blob/main/docs/CLI.md) \| Complete CLI and daemon command reference for this release \| \| [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) \| Validated models, contexts, clients, limitations, and release evidence \| \| [docs/BENCHMARKING.md](https://github.com/nibia-ai/fabric/blob/main/docs/BENCHMARKING.md) \| Reproducible methodology and measured reference results \| \| [docs/ARCHITECTURE.md](https://github.com/nibia-ai/fabric/blob/main/docs/ARCHITECTURE.md) \| Fabric architecture and runtime boundaries \| \| [docs/SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/docs/SECURITY.md) \| Security model and current trust assumptions \| \| [docs/TROUBLESHOOTING.md](https://github.com/nibia-ai/fabric/blob/main/docs/TROUBLESHOOTING.md) \| Common operational issues \| \| [docs/DEPENDENCIES.md](https://github.com/nibia-ai/fabric/blob/main/docs/DEPENDENCIES.md) \| Runtime and third-party dependency boundaries \| \| [docs/ROADMAP.md](https://github.com/nibia-ai/fabric/blob/main/docs/ROADMAP.md) \| Current project direction \| \| [CONTRIBUTING.md](https://github.com/nibia-ai/fabric/blob/main/CONTRIBUTING.md) \| Contribution workflow and DCO \| \| [GOVERNANCE.md](https://github.com/nibia-ai/fabric/blob/main/GOVERNANCE.md) \| Current project stewardship \| ## Experimental status This is an Experimental Alpha. CLI details, APIs, state formats, scheduling behavior, and compatibility may change. The current release is CPU-first. GPU pooling, Android nodes, LoRA/QLoRA training, NIBIA Hub/cloud, custom UI, and explicit unsafe/max-capacity modes are outside this alpha release. NIBIA Fabric is license	abelop	1	3
🟧 echo.github ⭐	The repo is the primary artifact the Show HN announces — README: "NIBIA Fabric — Turn everyday computers into a shared AI compute cluster. O	nibia-ai (NIBIA; org of Abraham D. Lopez, HN user "abelop")	—	—
🟠 reddit	Ran a 120B model across 6 computing devices that had no business running it! LocalLLaMA	Medicine_Blogscanner	3	10

source

object

author

score

comments

🟧 hn

Show HN: Nibia Fabric – Turn everyday computers into a shared AI compute cluster

Retrieved article excerpt

Open article · Retrieved 2026-09-28T18:37:04.354844+00:00

# NIBIA Fabric — Turn everyday computers into a shared AI compute cluster.

**Open-source distributed LLM inference across Mac, Windows, and Linux using aggregate CPU and system memory (RAM).**

[Nibia](https://github.com/nibia-ai/fabric/blob/main/docs/assets/nibia-logo.png)

**NIBIA Fabric** is the open-source distributed compute core of **NIBIA**. This Experimental Alpha is a CPU-first local AI compute fabric that coordinates computers on the same trusted LAN and partitions GGUF model execution across the fabric, allowing larger models to use the aggregate CPU and RAM capacity of multiple nodes instead of depending on a single machine.

> **Small models stay local. Larger models can expand across the fabric when they need more memory.**

Release: **v0.7.0 Experimental Alpha**  
CLI version: **v0.7.0-alpha**  
Wire protocol: **2**  
License: **Apache-2.0**

## Download

NIBIA Fabric v0.7.0 Experimental Alpha is available as prebuilt binaries.
Choose the archive for your operating system:

| Platform | Download |
| --- | --- |
| **macOS Apple Silicon** | [Download macOS arm64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-macos-arm64.zip) |
| **Linux x86-64** | [Download Linux amd64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-linux-amd64.zip) |
| **Windows x64** | [Download Windows amd64](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/nibia-v0.7.0-alpha-windows-amd64.zip) |
| **SHA-256 checksums** | [Download checksum file](https://github.com/nibia-ai/fabric/releases/download/v0.7.0-alpha/NIBIA_v0.7.0-alpha_SHA256SUMS.txt) |

**Verify the SHA-256 checksum before installation.**

> GitHub also generates automatic **Source code (zip)** and **Source code (tar.gz)**
> archives for every release. These are source snapshots, not the prebuilt NIBIA
> packages intended for normal installation. Use the platform downloads above.

After downloading, follow the [Quickstart](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) to install NIBIA,
configure the Primary Node, and pair additional Worker Nodes.

See the complete [v0.7.0 Experimental Alpha release](https://github.com/nibia-ai/fabric/releases/tag/v0.7.0-alpha).

## Supported release platforms

Prebuilt binaries for this Experimental Alpha are provided for:

- **macOS arm64** — Apple Silicon
- **Linux amd64** — x86-64
- **Windows amd64** — x64

Any supported desktop platform can be the **Primary Node**. Primary is a Fabric role, not an OS-specific tier: it is the node running the Controller, Coordinator, Agent, CLI, and local compute for that Simple Mode session.

**32-bit operating systems and CPU architectures are not supported.**

## Why NIBIA Fabric

Modern local AI is often limited by the memory and compute available on one computer. NIBIA Fabric uses hardware you already have around you and turns it into one coordinated inference fabric.

- **Expand model capacity beyond one machine.** Use safe RAM capacity from multiple computers for models that do not fit comfortably on the Primary alone.
- **Use heterogeneous everyday hardware.** Mix supported Mac, Windows, and Linux nodes on the same fabric.
- **Activate only what is needed.** Minimum Safe Fabric selects the smallest fresh worker subset that can satisfy the safe execution plan.
- **Keep the serving surface local by default.** The Web UI and OpenAI-compatible API bind to localhost on the Primary in this alpha.
- **Avoid heavy end-user toolchains.** Prebuilt NIBIA binaries manage a pinned, verified, precompiled llama.cpp runtime.

## How it works

In the default **Simple Mode**, one supported computer is chosen as the Primary Node and runs the Controller, Coordinator, Agent, CLI, and local compute. Additional computers run persistent NIBIA Agents. macOS, Linux, and Windows are peers at the role level; the reference lab often uses a Mac as Primary, but the architecture does not require it. Remote llama.cpp RPC workers and secure relays are activated only when a workload needs them.

```
                         trusted LAN

     Primary Node                         Worker Nodes
┌──────────────────────────┐        ┌──────────────────────┐
│ Controller + Coordinator │◄──────►│ NIBIA Agent          │
│ Agent + CLI              │  mTLS  │ on-demand RPC worker │
│ local CPU / Metal + RAM  │        │ CPU + RAM            │
│ GGUF model file          │        └──────────────────────┘
│ localhost API / Web UI   │        ┌──────────────────────┐
└──────────────────────────┘◄──────►│ NIBIA Agent          │
                                    │ on-demand RPC worker │
                                    │ CPU + RAM            │
                                    └──────────────────────┘
```

Workers do **not** need their own copy of the GGUF. NIBIA Fabric does not create a physical shared-memory address space; it makes independent node memory useful through distributed runtime placement and model partitioning.

## Run once or serve persistently

NIBIA exposes two primary inference lifecycles:

- **`nibia run`** — load the model, execute one prompt (or an explicitly requested terminal session), print the response, clean up the workload, and exit. Use it for terminal inference, scripts, and benchmarks.
- **`nibia serve`** — load the model once and keep it resident for the built-in Web UI and local OpenAI-compatible API until `Ctrl+C`. Use it for interactive use and repeated requests.

Example persistent server:

```
nibia serve \
  --model ~/Models/model.gguf \
  --ctx 4096 \
  --port 8081 \
  --controller http://127.0.0.1:8080
```

The context value is explicit because supported/useful context varies by model and workload. `--port` and `--controller` remain configurable; SERVE itself stays loopback-only by default in this Experimental Alpha.

## What works today

- Persistent NIBIA Agents with on-demand llama.cpp RPC workers.
- Minimum Safe Fabric / Lazy Worker Activation with adaptive per-node memory reserve.
- CPU execution on Linux/Windows and Apple Silicon Metal execution on macOS, with remote capacity expansion.
- TLS 1.3 mTLS Agent control traffic and authenticated reverse RPC relay after pairing.
- Raw llama.cpp RPC kept loopback-only on workers.
- Pinned, SHA-256-verified managed llama.cpp runtime (`b10902`, commit `df03399`).
- Persistent worker-local RPC tensor cache.
- Local built-in llama.cpp Web UI and OpenAI-compatible API.
- Bounded SERVE recovery after temporary selected-Agent loss.
- Workload-scoped Power Guard on macOS, Linux, and Windows.

## Get started

The release is **prebuilt-first**. Normal users do not need Go, Python, CMake, Visual Studio Build Tools, Homebrew, or a local llama.cpp source build.

The [Quickstart](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) walks through the complete first-run path:

1. download and verify the release archive;
2. install NIBIA on each node;
3. create the Primary and pair Worker Nodes;
4. validate the fabric;
5. download a GGUF model to the Primary;
6. serve the model and open the built-in Web UI or local API.

**Start here: [QUICKSTART.md](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md)**

## Validated release coverage

Physical validation for this Experimental Alpha includes:

- **Qwen3 4B Q4\_K\_M**
- **Qwen3 14B Q6\_K**
- **Qwen3 30B-A3B Q4\_K\_M** — primary exhaustive release-validation workload
- **GPT-OSS 20B MXFP4**
- **Gemma 3 27B IT Q4\_K\_M**

The release also includes measured Wi-Fi vs Gigabit Ethernet testing, three-node wired execution, tensor-cache reuse testing, multiple context-size tests, lifecycle/recovery testing, and optional-client validation.

See [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) for the validation matrix and [docs/BENCHMARKING.md](https://github.com/nibia-ai/fabric/blob/main/docs/BENCHMARKING.md) for measured methodology and results. Measurements are reference data, not guaranteed performance.

## Built-in UI and validated external clients

The default interactive interface is the **llama.cpp Web UI** served locally by NIBIA Fabric. NIBIA Fabric also exposes a local OpenAI-compatible API.

Optional external clients physically validated in documented release test modes include:

- **[Open WebUI](https://github.com/open-webui/open-webui)**
- **[OpenClaw](https://github.com/openclaw/openclaw)**

They are independent projects and are not required NIBIA Fabric dependencies. See [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) for the tested modes.

## Security defaults

NIBIA Fabric v0.7.0-alpha is intended for a **trusted local network**.

- SERVE binds to localhost by default.
- Controller administrative operations are localhost-only.
- Initial pairing uses a short-lived trusted-LAN bootstrap code.
- After pairing, Agents authenticate to the Controller with TLS 1.3 mTLS.
- Raw llama.cpp RPC is not exposed directly on the LAN.
- Managed llama.cpp downloads are pinned and SHA-256 verified before execution.

See [docs/SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/docs/SECURITY.md) and [SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/SECURITY.md).

## Runtime and ecosystem

NIBIA Fabric uses or interoperates with independent upstream projects that retain their own licenses and project identities:

- **[llama.cpp](https://github.com/ggml-org/llama.cpp)** — MIT-licensed upstream project; pinned managed inference runtime, Web UI/server, GGUF execution, and RPC backend used by this release.
- **[Open WebUI](https://github.com/open-webui/open-webui)** — separately licensed optional external UI; not bundled with NIBIA Fabric.
- **[OpenClaw](https://github.com/openclaw/openclaw)** — MIT-licensed optional external client/agent integration; not bundled with NIBIA Fabric.

NIBIA Fabric itself is licensed under **Apache-2.0**. Third-party projects retain their own upstream license terms. See [NOTICE](https://github.com/nibia-ai/fabric/blob/main/NOTICE) and [docs/DEPENDENCIES.md](https://github.com/nibia-ai/fabric/blob/main/docs/DEPENDENCIES.md).

## Documentation

| Document | Purpose |
| --- | --- |
| [QUICKSTART.md](https://github.com/nibia-ai/fabric/blob/main/QUICKSTART.md) | Install, pair nodes, download a model, and serve it |
| [docs/CLI.md](https://github.com/nibia-ai/fabric/blob/main/docs/CLI.md) | Complete CLI and daemon command reference for this release |
| [RELEASE\_NOTES.md](https://github.com/nibia-ai/fabric/blob/main/RELEASE_NOTES.md) | Validated models, contexts, clients, limitations, and release evidence |
| [docs/BENCHMARKING.md](https://github.com/nibia-ai/fabric/blob/main/docs/BENCHMARKING.md) | Reproducible methodology and measured reference results |
| [docs/ARCHITECTURE.md](https://github.com/nibia-ai/fabric/blob/main/docs/ARCHITECTURE.md) | Fabric architecture and runtime boundaries |
| [docs/SECURITY.md](https://github.com/nibia-ai/fabric/blob/main/docs/SECURITY.md) | Security model and current trust assumptions |
| [docs/TROUBLESHOOTING.md](https://github.com/nibia-ai/fabric/blob/main/docs/TROUBLESHOOTING.md) | Common operational issues |
| [docs/DEPENDENCIES.md](https://github.com/nibia-ai/fabric/blob/main/docs/DEPENDENCIES.md) | Runtime and third-party dependency boundaries |
| [docs/ROADMAP.md](https://github.com/nibia-ai/fabric/blob/main/docs/ROADMAP.md) | Current project direction |
| [CONTRIBUTING.md](https://github.com/nibia-ai/fabric/blob/main/CONTRIBUTING.md) | Contribution workflow and DCO |
| [GOVERNANCE.md](https://github.com/nibia-ai/fabric/blob/main/GOVERNANCE.md) | Current project stewardship |

## Experimental status

This is an **Experimental Alpha**. CLI details, APIs, state formats, scheduling behavior, and compatibility may change. The current release is CPU-first. GPU pooling, Android nodes, LoRA/QLoRA training, NIBIA Hub/cloud, custom UI, and explicit unsafe/max-capacity modes are outside this alpha release.

NIBIA Fabric is license

abelop

🟧 echo.github ⭐

The repo is the primary artifact the Show HN announces — README: "NIBIA Fabric — Turn everyday computers into a shared AI compute cluster. O

nibia-ai (NIBIA; org of Abraham D. Lopez, HN user "abelop")

—

🟠 reddit

Ran a 120B model across 6 computing devices that had no business running it!

LocalLLaMA

Medicine_Blogscanner

Interpretation history

2026-10-09T02:35:59Z
grounded: converges/high — Nibia Fabric independently arrives at distributed CPU/RAM pooling via partitioned GGUF execution — a new axis for Scott's hardware-aware local inference substra
2026-10-09T02:27:22Z
Independent user replication arrived: a Reddit poster demonstrated running a 120B model across six heterogeneous devices (laptop, mini PC, Macs, Android) via distributed inference, directly corroborating the maintainers' claim that partitioned GGUF execution can pool CPU/RAM beyond any single node. This satisfies the case's replication condition with a second independent line of evidence.
2026-10-08T23:06:43Z
evidence attached: reddit.post.1x0ubuc — Concrete user demonstration of running a 120B model across six heterogeneous devices (laptop, mini PC, Macs, Android) via distributed inference, independently corroborating the case's hypothesis about practical cross-device CPU/RAM pooling.
2026-09-28T19:49:12Z
origin walked (opencode/cheap-glm, conf 0.9): anchor hn.story.49882129 -> echo.github.d6189824aa by nibia-ai (NIBIA; org of Abraham D. Lopez, HN user "abelop")
2026-09-28T19:14:08Z
grounded: novel/medium — Sits directly on the substrate Scott operates — the gamepc/Ollama single-node GGUF serving stack — and proposes a new axis for his hardware-aware-local-inferenc
2026-09-28T19:06:32Z
case created — Concrete first-party artifact (release binaries, architecture docs, validation matrix) in Scott's local-inference area, though currently near-zero engagement.

Decision trace

10-09 15:03attention_communicatedA Reddit user successfully ran GPT-OSS-120B (4-bit, ~60GB) across six heterogeneous devices — 12GB Windows laptop, RTX 3060 mini PC (12GB), M1 Mac mini (16GB), M3 MacBook (16GB), 2017 Intel MacBook, a
10-09 15:03attention_routePrevious judgment was 'watch' pending independent replication. That threshold is now met: a user demonstrated a 120B model exceeding any single node's memory across heterogeneous hardwa
10-09 13:40attention_routePrevious judgment was 'watch' pending independent replication. That threshold is now met: a user demonstrated a 120B model exceeding any single node's memory across heterogeneous hardwa
10-09 13:35attention_candidatematerial_reprice
10-09 13:35repriceIndependent user replication arrived: a Reddit poster demonstrated running a 120B model across six heterogeneous devices (laptop, mini PC, Macs, Android) via distributed inference, directly corroborat
10-09 13:35groundNibia Fabric independently arrives at distributed CPU/RAM pooling via partitioned GGUF execution — a new axis for Scott's hardware-aware local inference substrate (gamepc/Ollama) that extends mod
10-09 10:15attention_routeThe editor compared this story and chose to keep watching.
10-09 10:06attention_candidateattach
10-09 10:06attachConcrete user demonstration of running a 120B model across six heterogeneous devices (laptop, mini PC, Macs, Android) via distributed inference, independently corroborating the case's hypothesis
10-09 09:39propose_attachConcrete user demonstration of running a 120B model across six heterogeneous devices (laptop, mini PC, Macs, Android) via distributed inference, independently corroborating the case's hypothesis
09-30 16:42review_screenjev screen: no material development (noul=0.05)
09-29 12:22sensor_dirtycomment_update
09-29 05:49promote_anchororigin walk conf 0.9
09-29 05:14groundSits directly on the substrate Scott operates — the gamepc/Ollama single-node GGUF serving stack — and proposes a new axis for his hardware-aware-local-inference position that memory pressure is expli
09-29 05:06createConcrete first-party artifact (release binaries, architecture docs, validation matrix) in Scott's local-inference area, though currently near-zero engagement.