An Umbrel community app store bringing together all of Paul Lamb's Umbrel apps under one heading.
- Open your Umbrel dashboard.
- Go to App Store.
- Click the ellipsis (⋯) in the upper-right, then Community App Stores.
- Paste the URL of this repo:
https://github.com/paulscode/umbrel-store - Click Add.
- The PaulsCode.Com app store now appears under its own heading.
| App | What it does | Requires |
|---|---|---|
| Agent Wallet | Self-custodial Bitcoin & Lightning wallet with an automation API for AI agents | Lightning Node (LND) + Electrs/Fulcrum |
| Knots (BLAKE2b) Companion | A pruned Bitcoin Knots node following the BLAKE2b chain, alongside your existing node | none (self-contained) |
| Lightning Fork | A Lightning Network node (LND fork) for the BLAKE2b chain, beside the official Lightning Node | Knots (BLAKE2b) Companion (or Bitcoin Knots 29.4.1+) |
| Datum (BLAKE2b) Companion | Solo mine the BLAKE2b chain with a Sia-style ASIC you already own | Knots (BLAKE2b) Companion |
| Knots (SHA256) | A full node running Bitcoin Knots SHA256: Knots' policy on Bitcoin Core 31.1, as your Bitcoin node | none (self-contained) |
| Knots (SHA256) Companion | The same node, pruned, beside your existing one | none (self-contained) |
| Datum (SHA256) Companion | Solo or pooled mining against that node, with your own block templates | Knots (SHA256) Companion |
| Electrs Liquid | A Liquid (liquidv1) full node bundled with an Electrum indexer |
none (self-contained) |
| Electrs Pruned | An Electrum server that indexes from a pruned node, beside the official Electrs | Bitcoin Node |
| HashGG | Sovereign hash routing — exposes your Datum stratum port to the public internet | Datum (→ Bitcoin Knots) |
| HashGG Companion | The same hash routing, pointed at the Companion Datum Gateway | Datum (BLAKE2b) Companion |
| Mempool Pruned | Mempool block explorer that works against a pruned Bitcoin node | Bitcoin Node + Electrs Pruned |
| Pickhash | Autonomously rents Bitcoin hashrate from MiningRigRentals and points it at your own pool | none (optional: HashGG) |
A self-custodial Bitcoin and Lightning wallet that connects to your Umbrel's Lightning Node (LND) and exposes a dashboard plus a programmatic API designed for AI agents to initiate payments within configured limits. It uses your installed Electrum indexer (Electrs or Fulcrum) for on-chain lookups, and an optional Mempool explorer (the official Mempool) for fee estimates and links. It also includes a BOLT 12 onion-message gateway and an optional, experimental Anonymize feature (with an optional Liquid hop that can use Electrs Liquid below).
The dashboard password and API keys spend real money. Anyone holding either can spend from the connected LND node up to its limits. Treat them like cash. Get your dashboard password by right-clicking the Agent Wallet tile and choosing Show default credentials — that value is your login.
The wallet bundles its own PostgreSQL, Redis, and Tor (supervised by s6-overlay) in a single container — the same image contract as the StartOS package.
Requirements: Lightning Node (LND) — required; Electrs or Fulcrum — required; Mempool — optional.
Umbrel has no per-app settings form, so feature toggles default to sensible
values. To change them, edit the environment: block of the web service in
paulscode-agent-wallet/docker-compose.yml
and restart the app:
| Variable | Default | Effect |
|---|---|---|
AGENT_WALLET_BOLT12 |
true |
BOLT 12 onion-message gateway |
AGENT_WALLET_BRAIINS_DEPOSIT |
true |
Braiins deposit tab |
AGENT_WALLET_ANONYMIZE |
false |
Experimental Anonymize feature (needs Tor; bundled) |
AGENT_WALLET_LIQUID |
false |
Liquid hop for Anonymize (needs the Electrs Liquid app) |
AGENT_WALLET_LOG_LEVEL |
INFO |
ERROR / WARN / INFO / DEBUG / TRACE |
- Source: https://github.com/paulscode/agent-wallet
- Issues: https://github.com/paulscode/agent-wallet/issues
LND with the changes needed to follow the Bitcoin BLAKE2b chain, behind the same dashboard the official Lightning Node app uses. It opens and closes channels, routes payments, and sends and receives over the Lightning Network on that chain. It marks its peer handshakes, invoices and offers with a required feature bit that a Lightning node or wallet on Bitcoin following the specification refuses, and refuses any invoice or offer without it, so it cannot reach the Bitcoin Lightning network by accident.
Which Bitcoin node it follows is chosen in the app's node selector, the same one every app that depends on a Bitcoin node gets. Two qualify: Knots (BLAKE2b) Companion above, and Bitcoin Knots once it is on 29.4.1 or later. The daemon checks the node when it starts and refuses one it cannot confirm is on the BLAKE2b chain; the app's tile then shows why, in words, rather than a spinner. Bitcoin Core and any Knots below 29.4.1 are refused.
Real money on a young chain. Coins that existed before block 961640 exist on both chains. Lightning Fork signs with the chain's replay-protected signature type, but prefer funding channels with coins received after that block, and keep amounts modest. Back up after every channel open or close.
Connecting: wallets that speak lndconnect (Zeus and the like) connect exactly as to LND, through the dashboard's connect modal. The app listens on 9737 (peers), 10010 (gRPC) and 8180 (REST); the official Lightning Node app keeps 9735, 10009 and 8080, so both can be installed at once.
- Source: https://github.com/paulscode/lightning-fork
- Issues: https://github.com/paulscode/lightning-fork/issues
Two apps for one chain: a node that follows it and a gateway that lets a Sia-style ASIC mine it.
Bitcoin's mainnet split on 30 August 2026. The two chains part at block 961632, and from block 961640 one of them uses BLAKE2b for proof of work instead of SHA256d. BLAKE2b is the algorithm Sia mines, so ASICs built for Sia can mine that chain. Knots (BLAKE2b) Companion runs a node that follows it and enforces its rules; Datum (BLAKE2b) Companion turns that node's block templates into Stratum work in the dialect Sia miners speak.
This is a real chain with real block rewards. Blocks you mine here pay a real subsidy to a real address, and the chain has other participants. Both sides of the split claim to be Bitcoin. Which one you follow is your decision, and installing these makes it.
Install the node first, then the gateway, which connects to it automatically. The node installs alongside your existing Bitcoin node rather than in place of it, on its own ports and its own data, and is pruned to about 5 GB by default so both chains fit on one server. Its first sync downloads the chain from the network and takes a while.
The node runs the same web interface the official Bitcoin Knots app runs, from a
fork of that app's image: the same dashboard, block and peer lists, connect modal,
Advanced Settings and home-screen widgets. Opening the gateway opens the DATUM
Gateway dashboard, behind umbrelOS's proxy, with a working admin login from "Show
default credentials" on the app icon; the username is admin.
Set a payout address before you mine. There is no default, because a default would mean sending your block rewards to somebody else. It goes under the gateway's Config tab, and it should be an address whose keys you hold: solo mining means a block you find pays its whole subsidy there.
Use your server's IP address, not a .local name. Most ASIC firmware has no
mDNS resolver, so a .local pool address fails silently and the miner simply
reports that the pool is not ready. This is the single most common reason a miner
appears not to work.
Ports: Stratum on 23336, and the two app tiles on 7150 (node) and
7153 (gateway). These avoid the official
Datum app's 23334 and the official Bitcoin
Knots app's ports, so all of them can be installed on the same server, and they
stay out of the 3000s where app tiles crowd together.
These results were gathered against the test chains these apps ran before the mainnet split, so they measure the Stratum dialect rather than the chain. The dialect is unchanged. All on stock firmware with no modifications:
- Goldshell HS-Box (firmware 2.2.4) in Sia mode, tested directly — it connects, receives BLAKE2b work, and the blocks it finds are accepted with no rejections.
- Bitmain Antminer A3 (CGminer 4.9.0), reported by a user — 158 of 161 shares accepted over a two-hour session.
- Goldshell SC5 Pro (firmware 2.2.0), reported by a user — 272 of 299 shares accepted, and 199 of the 298 blocks it found accepted by the node.
- Goldshell SC Box II (firmware 2.2.2), reported by a user — 382 of 384 shares accepted, and 346 of the 383 blocks it found accepted by the node.
- Innosilicon S11 (firmware s11_20190424_095412), reported by a user — 60 of 61 shares accepted, and 48 of the 61 blocks it found accepted by the node.
Five devices across three manufacturers and three mining stacks (intminer,
cgminer, sgminer), all speaking to the gateway identically. That spread is what
makes the result mean something: it is the Sia dialect, not one vendor's idea of
it. Other Sia BLAKE2b miners are expected to work but have not been tried.
GPUs do not work yet. ccminer -a sia computes exactly the right hash, but it
speaks the other "Sia stratum" — the one the Sia pools use, with 4-byte time and
nonce fields and a ready-made merkle root — while this gateway serves the dialect
the ASICs speak. Tested directly on an RTX 3090 and a Quadro RTX 8000: it rejects
the job and never starts hashing. A GPU miner is possible but would mean teaching
one the other dialect, not finding the right flag.
The compatibility-report form and its capture port on 23337 are gone. They
existed to gather the list above, the question they answered is answered, and a
second Stratum port that recorded miner traffic is not something to leave running
against a chain carrying real rewards. If your miner was pointed at 23337, point
it at 23336.
If your hardware is not on that list, results are welcome in the Bitcoin section of the forum (posting needs a free account) or as a GitHub issue.
- Source: https://github.com/paulscode/knots-blake2b-startos
- Source: https://github.com/paulscode/datum-blake2b-startos
- Questions and results: https://paulscode.com/c/bitcoin/8
Bitcoin nodes and a mining gateway for the SHA256 chain, the one your existing Bitcoin app already follows. Both nodes run Bitcoin Knots SHA256: Bitcoin Knots' relay and mining policy, maintained on top of Bitcoin Core 31.1. They accept exactly the blocks Bitcoin Core accepts; what differs is policy (what the node relays and what goes into its block templates follows Knots' stricter defaults). They never enforce BIP-110 (RDTS), which the official Bitcoin Knots app's current releases do, so they stay on the chain Bitcoin Core follows. Releases, notes and source: https://github.com/paulscode/knots-sha256
Knots (SHA256) is a full node to use as your Bitcoin node: apps that need one (Electrs, Lightning, mempool, Datum…) can select it, and it keeps the whole chain by default. Knots (SHA256) Companion is the same node, pruned, to run beside the node your other apps already use, with its own data, ports and settings.
Both run one image, the web interface the official Bitcoin Knots app runs with one bitcoind inside: the published Bitcoin Knots SHA256 release, built reproducibly and checked against the maintainer's signing key when the image is built (https://github.com/paulscode/umbrel-bitcoin-knots-sha256). So the dashboard, block and peer lists, connect modal, Advanced Settings and widgets are the ones you already know, and the Version setting has one entry.
Companion users, from 31.1.0: the node moves from Bitcoin Knots 29.3 to Bitcoin Knots SHA256 31.1. Settings, pruning and the synced chain carry over; the old Version pin is replaced by the one build. While pruning is on, block filters are switched off when settings are saved, because a pruned node cannot build that index.
Datum (SHA256) Companion connects to it automatically on install and mines its chain. Unlike the BLAKE2b gateway, where no pool can validate a share, this one builds SHA256d templates that every DATUM pool understands, so solo and pooled mining both work. Leave the DATUM Pool settings empty and a block you find pays its whole subsidy to your address; fill them in and you mine to a pool while still building your own templates.
Set a payout address before you mine. There is no default, because a default
would mean sending your block rewards to somebody else. It is under the gateway's
Config tab, and the credentials for that tab are on your home screen: right
click the app icon and choose "Show default credentials". The username is
admin.
Use your server's IP address, not a .local name. Most ASIC firmware has no
mDNS resolver, so a .local pool address fails silently and the miner reports
only that the pool is not ready.
Disk: the full node keeps the whole chain, like the official Bitcoin app. The companion keeps about 5 GB of blocks by default, plus the node's own data; change it under Advanced Settings. The first sync downloads the chain from the network and takes a while: neither shares data with another node app.
Ports: the full node uses RPC 39332, P2P 39333 and its tile on
7152; the companion RPC 19332, P2P 19333 and tile 7151; the
gateway Stratum 23338 and tile 7155. These avoid the official Bitcoin
Knots app's 9332/9333 and the official Datum app's 23334, so every one of
them can be installed on the same server.
- Source: https://github.com/paulscode/knots-sha256
- Source: https://github.com/paulscode/umbrel-bitcoin-knots-sha256
- Source: https://github.com/paulscode/datum-sha256-startos
Runs a Liquid full node (elementsd) and an Electrum indexer (electrs, built
--features liquid) together in one app. Other apps and wallets can use the
Electrum endpoint to query Liquid balances and transaction history and to
broadcast transactions, without relying on external Liquid Electrum servers.
Heavyweight. Stores the full Liquid chain plus its address index (~115 GB of disk) and uses ~14 GiB of RAM during the initial sync. It is meant to run alongside other Bitcoin/Lightning services, so ≥32 GB of total RAM is recommended. The first sync can take many hours. Self-contained: it does not require the Bitcoin app.
Connecting:
-
Other Umbrel apps can add
paulscode-electrs-liquidas a dependency and readAPP_ELECTRS_LIQUID_ELECTRS_NODE_IP/_NODE_PORT(internal Electrum port50001). -
Wallets on your LAN can connect an Electrum-compatible Liquid wallet to your Umbrel's address on port 50101 (mapped to the indexer's internal
50001;50101avoids colliding with the Bitcoin Electrs app's50001).
An Electrum server for a node that is not keeping the whole chain. The official Electrs app requires an archival node with transaction indexing, which means holding every block forever. This one indexes from a pruned node and fetches the blocks your node has dropped from the peer-to-peer network, checking each one against your node before using it.
It runs beside the official Electrs rather than replacing it. The setup it is
built for is two nodes on one server: an archival node with the official Electrs
on 50001, and a pruned node with this on 50201. Both chains stay reachable
from your own hardware without paying for the disk to hold two full blockchains.
The app runs two containers. The indexer is electrs, patched to route requests
for old blocks past the point where your node stopped keeping them. Beside it
runs btc-rpc-proxy, which fetches those blocks over peer-to-peer and verifies
them against your node, so nothing is trusted that your node has not confirmed.
Nothing is changed on your Bitcoin node, and an archival node works too: the
routing only engages below a prune height, so with no prune height it never
engages.
A pruned node saves disk on blocks, not on the index. Expect roughly 60 to 80 GB for the address index on mainnet and a first sync measured in hours. Fetching a dropped block costs a network round trip, so a wallet asking about very old transactions is slower than it would be against an archival node. Recent history is unaffected.
Privacy. Ordinary wallet use fetches nothing from peers: balances, history and unspent outputs come from the index this app builds, so your addresses never leave your server. Blocks your node has dropped are fetched from the network, and a peer serving you one learns you wanted it. During the first index that only shows you are syncing; afterwards a few requests still reach for a block on demand, and those follow from something you asked for. If your Bitcoin node runs over Tor, these fetches do too. An archival node with the official Electrs never fetches at all, and is the more private option if this tradeoff is not one you want.
Connecting:
-
Other Umbrel apps can depend on this app and read
APP_ELECTRS_PRUNED_SERVER_IP/APP_ELECTRS_PRUNED_SERVER_PORT(internal Electrum port50001). -
Wallets on your LAN can point an Electrum-compatible wallet at your server's address on port 50201. The official Electrs app keeps
50001, so both can be installed and both connected to at once.
Sovereign hash routing for your Bitcoin miners. Exposes your Datum Gateway stratum port to the public internet via playit.gg or an SSH tunnel to a VPS you control — so any miner, anywhere, can connect to your node and mine blocks you built. No router configuration, no dynamic DNS, no VPN; works behind NAT, double NAT, or CGNAT.
Requires the official Datum Umbrel app (which in turn requires the Bitcoin Knots app). Install Datum first, then install HashGG and pick a tunnel mode in its web UI.
The same sovereign hash routing as HashGG above, pointed at a different gateway. HashGG pairs with the official Datum Gateway app, whatever chain that build follows. This one pairs with Datum (BLAKE2b) Companion, which exists so a second gateway can run beside the first.
It installs and runs beside the ordinary HashGG rather than replacing it. One server can expose both gateways at once, and the two keep separate settings, separate playit.gg tunnels, and separate access to any VPS they share, so setting one up never disturbs the other. If you run both, the tile with COMPANION across the bottom of the icon is this one.
The optional "make your Bitcoin node reachable" feature offers your BLAKE2b node here, and never touches the main Bitcoin package, which is the ordinary HashGG's job. That separation is why the two can run together without one advertising an address for the other's chain.
Two tunnel options, chosen in the web UI: playit.gg, a managed service and the easiest setup, or a VPS SSH tunnel, with no third party on the data path.
Nothing to forward until your node has synced. A Datum Gateway does not open its stratum port until it has its first block template, and it cannot get one from a node that is still catching up. Until then this app says it is waiting. On a fresh node that is hours, and it needs no action.
Requires Datum (BLAKE2b) Companion, which in turn requires Knots (BLAKE2b) Companion.
Your own mempool.space against a pruned node. The official Mempool app requires an archival node with transaction indexing; this one does not.
Mempool normally looks up a confirmed transaction by asking Bitcoin for it directly, which only works if the node keeps a transaction index, and that index cannot be built on a pruned node. This build asks the Electrum server instead. That server has its own index and fetches any block your node has dropped from the peer-to-peer network, so the explorer sees a complete chain on a node that is not keeping one.
Requirements: install Electrs Pruned first and let it finish indexing. The official Electrs app will not do, because it requires an archival node, which is the requirement this app exists to remove. Your Bitcoin node may be pruned or archival; nothing here asks you to change it either way.
Point both apps at the same node. Umbrel asks which Bitcoin node to use when you install this. Pick the one you picked for Electrs Pruned. This explorer reads its blocks through that app, so pointing the two at different nodes gives you an explorer describing a chain it is not reading. Either node works, including the BLAKE2b companion, as long as both apps agree.
Blocks below your node's prune height are fetched from the network on demand, so an old block page is slower than a recent one, and the page says so while it works. Recent history is unaffected. The explorer keeps its own database, which is separate from the chain and still needs room.
Installs alongside the official Mempool. Each keeps its own database, address and port.
- Source: https://github.com/paulscode/mempool-pruned-startos
- Upstream: https://github.com/paulscode/mempool-pruned
Rent Bitcoin hashrate on your own terms. Pickhash autonomously rents SHA-256 (AsicBoost) hashrate from MiningRigRentals and points it at your stratum endpoint — typically your Bitcoin node behind a Datum Gateway — so the hashrate you pay for mines your block templates.
You set a target hashrate, a budget, and a duration; Pickhash finds reliable rigs, prices and creates the rentals, points them at your pool, and watches over delivery (ramp-up, under-delivery, offline rigs, refunds). It starts in DRY-RUN (a rehearsal that spends nothing); going LIVE requires a dashboard password.
Pickhash spends real Bitcoin on your behalf, within the budget and guardrails you set. Marketplace credentials are encrypted at rest. Set a dashboard password before switching to LIVE.
Optionally pair it with the HashGG app above to auto-discover your
public stratum endpoint — not required; you can enter any reachable host:port.
- Umbrel (umbrelOS 1.x or later)
- Per-app dependencies as listed above.
The container images referenced by these apps are published to Docker Hub under
paulscode/* and pinned by digest in each app's docker-compose.yml. The
scripts that build and push them live in build/ — see
build/README.md.
- Store issues (packaging): https://github.com/paulscode/umbrel-store/issues
- Per-app issues: see each app's links above.
- Umbrel (general): https://community.umbrel.com
MIT — see LICENSE.
- Architecture: all images are published multi-arch (linux/amd64 + linux/arm64). The arm64 builds have not been hardware-tested by the author; please report issues if you hit any.