# Darkbloom

> Private inference network that turns idle Apple Silicon Macs into an OpenAI-compatible cloud

- Category: Models & Inference / GPU & Compute Clouds
- Language: Go
- Licence: Custom (see repository LICENSE)
- Repository: https://github.com/Layr-Labs/d-inference
- Website: https://darkbloom.dev
- Canonical page: https://ai-tldr.dev/tools/darkbloom/
- Updated: 2026-04-15

## In short

Darkbloom is a decentralized private-inference network for Apple Silicon. It sits in the GPU & Compute Clouds category of the Models & Inference tools and is open-source, written in Go and licensed Custom (see repository LICENSE). To get started: get an API key.

## Overview

Darkbloom is a decentralized private-inference network for Apple Silicon. Consumers call a standard HTTPS, OpenAI-compatible API; a Go coordinator running in a GCP Confidential VM authenticates the request, picks a provider, handles billing and relays the payload; and providers are Macs running the `darkbloom` Swift CLI, which connect outbound over WebSocket and run inference in-process on the GPU via MLX. Because providers dial out, no port forwarding or inbound firewall change is needed to run one.

The hard problem the project sets itself is that the person running a provider node has root and physical custody of the machine doing your inference, yet must not be able to read your prompts or the responses. Darkbloom closes the software paths to that plaintext: inference runs in-process via MLX so there is no subprocess, local server or IPC to tap; the process denies debugger attachment at the kernel level with `PT_DENY_ATTACH` and blocks memory-reading APIs through Hardened Runtime; the coordinator re-seals every request with NaCl Box (X25519 + XSalsa20-Poly1305) to the provider's attested key; and a four-layer attestation chain — Secure Enclave signatures, MDM cross-checks, Apple Managed Device Attestation and APNs code-identity — proves each node's posture.

The project is careful about what it does and does not claim. Plaintext is exposed only inside the coordinator's hardware-encrypted Confidential-VM memory, is never logged or retained, and is immediately re-encrypted for the selected provider; the residual threat is the same one Apple accepts for Private Cloud Compute, namely physically de-soldering and probing memory. Darkbloom is labelled public alpha, with breaking changes and downtime expected, and its billing invariants, platform fee and payout rules are stated once in the billing document.

## What it does

- OpenAI- and Anthropic-compatible API — most clients work by changing one base URL
- Providers are Apple Silicon Macs running a Swift CLI; inference runs in-process on the GPU through MLX
- Mandatory per-request NaCl Box encryption from the coordinator to the provider's attested X25519 key, with a fresh ephemeral key each request
- Provider hardening via Hardened Runtime, SIP and PT_DENY_ATTACH, immutable for the process lifetime
- Four-layer hardware attestation: Secure Enclave signatures, MDM SecurityInfo cross-check, Apple Managed Device Attestation and APNs code identity
- Per-response trust signals returned as X-Provider-Trust-Level, X-Provider-Attested, X-Provider-Encrypted and related headers
- Providers connect outbound over WebSocket, so no port forwarding or inbound firewall rules are required

## Getting started

There are two ways in. As a consumer you point an OpenAI SDK at the Darkbloom base URL. As a provider you run the Swift CLI on an Apple Silicon Mac and let it sell idle capacity. Both paths are documented in the repository; the consumer path is the fastest thing to try.

1. Get an API key

   Create a key in the Darkbloom console at console.darkbloom.dev. Keys look like sk-db-…; a Privy session JWT also works as the bearer token.

2. Point an OpenAI client at Darkbloom

   The API is OpenAI-compatible, so the only change is the base URL. Use a model id returned by GET /v1/models.

```python
from openai import OpenAI

client = OpenAI(
    base_url="https://api.darkbloom.dev/v1",
    api_key="sk-db-...",
)

stream = client.chat.completions.create(
    model="gemma-4-26b",
    messages=[{"role": "user", "content": "Hello, Darkbloom!"}],
    stream=True,
)
```

3. Check which provider served you

   Committed responses carry provider headers — X-Provider-Trust-Level, X-Provider-Attested, X-Provider-Encrypted, X-Provider-Chip and X-Provider-Secure-Enclave. Set metadata_details: true (or the X-Darkbloom-Metadata-Details header) on POST /v1/chat/completions to get the same fields back in a JSON metadata object instead.

4. Run a provider node

   On an Apple Silicon Mac, follow the Run a provider section of the README to install the darkbloom Swift CLI. The node connects outbound to the coordinator, so no inbound firewall changes are needed; payouts and the platform fee are documented in docs/architecture/billing.md.

## When to use it

- Serve inference where the machine operator must not be able to read prompts or responses, without building your own confidential-computing stack
- Point an existing OpenAI or Anthropic SDK application at a cheaper inference backend by changing the base URL
- Monetise idle Apple Silicon capacity by running a provider node on hardware you already own
- Study a working design for attested, end-to-end encrypted inference across untrusted operator machines

## Version history

- 2026-04-15: Darkbloom, from Eigen Labs, opened as a private-inference network running on idle Apple Silicon Macs with hardware-backed privacy layers, and became a paid inference provider on OpenRouter.