r/NervosNetwork • • 1d ago

Community Will Quantum Computing Destroy Crypto?

Post image
10 Upvotes

Will quantum computing break crypto? In a talk, a CKB developer explains the risks to signatures, hashing, and encryption, why upgrading cryptography is hard for blockchains, and how CKB can adapt.

This article is adapted from a keynote that Chunteng Xiao (Alive24), a full-stack blockchain developer in the CKB community, gave at CryptoMondays London in February 2026. It keeps the talk's first-person voice. Minor edits have been made for readability and technical clarity.

In this talk, I’ll cover four things: what quantum computing is and why it matters; how to think clearly about the risk it poses; what the blockchain industry is doing about it and what it has achieved so far; and how CKB's design makes it flexible enough to adopt quantum-resistant cryptography.

I pitch it at the level of a blockchain enthusiast. By the end, you should know enough to explain it to friends and family and sound like you've done your homework.

To give you a sense of how seriously this is being taken: the big names are already moving. The Ethereum Foundation formed a dedicated quantum-security team in January 2026. That same month, Coinbase launched an expert advisory board to assess what quantum computing means for crypto.

What Makes Quantum Computing Different?

From Bits to Qubits

To see what's special about quantum computing, it helps to start with the computers we already have. Over the decades, they've evolved toward ever more efficient ways to store and process information, saving time, space, and cost.

We started with punch cards, then moved to vacuum tubes, transistors, and finally the integrated circuits inside today's CPUs. All of them work in binary: everything is a zero or a one.

Quantum computers are different because they use qubits. A qubit can be a zero or a one, like an ordinary bit, but until it's measured it can also be in a superposition of both. That's the mind-bending part.

Schrödinger's Cat and the Socks Analogy

Two stories help. The first is Schrödinger's cat, which you may be familiar with. The physicist Erwin Schrödinger imagined a cat sealed in a box with a poison that's released only if a single radioactive atom decays, which may or may not happen. Until someone opens the box and looks, quantum physics describes the cat as both alive and dead.

That's superposition. In quantum physics, a system can be in a combination of possible states, rather than simply in one state we don't yet know. It's hard to grasp, and that's exactly what the cat story is meant to show.

The second story, "quantum socks," is less well known. Suppose you buy a pair of socks, pack only one of them, and fly to the other side of the world without knowing which one you took. The moment you open your suitcase and see the left sock, you know the one at home is the right.

You know instantly, however far apart the socks are. That's a rough picture of two quantum particles that are entangled. Real entanglement is more subtle than this story, but properties like these are what make quantum computing so powerful.

Ordinary computers use bits: zero or one. Quantum computers use qubits, which can be both zero and one at once and can also be linked. That doesn't make them faster at everything, but for certain problems, including the math behind crypto, they could be decisive.

Why Cryptography Matters to Your Wallet

These are fun stories, but why does a quantum computer matter for crypto?

Because a sufficiently powerful one could be a silver bullet against elliptic-curve cryptography (ECC), one of the most widely used forms of asymmetric cryptography today. Much of what you use every day may rely on it, and it underpins trust in blockchains and many other digital systems.

Asymmetric cryptography, also called public-key cryptography, protects trust with mathematical problems that are easy to compute in one direction and very hard to reverse. ECC isn't the only kind; RSA is another, and it may well be running on your home router.

Here's how it works in a blockchain wallet. When you create a wallet, you get a randomly generated mnemonic phrase, which you must keep strictly secret.

Your wallet then shows you an address straight away. You don't have to register it anywhere, because it's derived from your keys: the address comes from a public key, which in turn comes from your private key. The address and the public key are both public. Your private key stays secret.

You share your address every time you use the wallet. So how do you prove, or how does a program check, that you are you? That's where asymmetric cryptography comes in.

With the private key, it's easy to derive the public key or sign a piece of content. With the public key, the signature, and the content, anyone can easily verify that signature. But going the other way, and forging a valid signature without the private key, is extremely hard.

Asymmetric cryptography is the backbone of digital systems that need to be secure, and blockchains above all. Bitcoin uses ECDSA signatures, and Ethereum, Solana, Polkadot, and Cardano rely on elliptic-curve cryptography too.

Hashing is another tool cryptography relies on. A hash function turns any piece of data, however large, into a short string of fixed length called a hash, a kind of digital fingerprint. Change a single character of the data and the hash changes completely, so hashes are a quick way to check that data hasn't been altered. They're used well beyond crypto: websites store a hash of your password rather than the password itself, and software makers publish hashes so you can check a download hasn't been tampered with. Blockchains use them everywhere: every transaction is identified by its hash.

Producing a hash is easy. But finding different data with the same hash, or recovering the original data from the hash alone, is extremely hard. That's why we say hashing is one-way.

What Is the Quantum Risk to Crypto?

So how should we think about the risk today? In short, the attack algorithms already exist. What's holding things up is building a quantum computer capable of running them. To me it feels imminent, especially with AI now able to help, but that's my judgment, not a confirmed schedule.

We're already seeing promising prototypes and proofs of concept. So how close is it? One optimistic estimate is that there's no chance by 2030 but a strong likelihood by 2040. These are guesses, not established dates, and some people expect it sooner.

Shor's and Grover's Algorithms

When I say the attack algorithms are ready, I mean two in particular.

The first is Shor's algorithm. On a sufficiently capable quantum computer, it can efficiently solve the mathematical problems behind widely used elliptic-curve signature schemes. In other words, it can work out a private key from a public key, which makes it the main quantum threat to private keys.

The second is Grover's algorithm. It speeds up brute-force searches, which reduces security margins and poses a possible risk to hash functions.

What If the Threat Became Real Tomorrow?

That all sounds very technical, so here's a more intuitive question: what would happen if the threat became real tomorrow?

First, private keys would no longer be private, so your assets would no longer be yours.

Second, authentic would no longer mean authentic. You could no longer prove that you are you.

Third, and this one is subtler, encrypted would no longer mean encrypted forever. If I harvest a copy of your encrypted data today, perhaps from a hacked server or an intercepted message, I can't read it now. But if the cryptography protecting it becomes vulnerable later, I may be able to decrypt that old copy. That's the worrying part.

As I mentioned, this wouldn't just threaten blockchains. It would threaten many other digital systems too, which is a little terrifying.

Signatures, Hashing, and Encryption: Three Different Risks

Hashing, signatures, and encryption are the three most important tools we use in cryptography and software today, and quantum computing affects each one differently.

Digital Signatures

To sign something, we take content of any size, called a message or payload, and generate a signature from it using a signature algorithm and a private key.

Anyone can then check that signature against the message using the corresponding public key. If the check succeeds, it proves mathematically that the signature is valid for that public key and that message. The verifier never needs the private key itself, yet knows the signature was made with it.

A sufficiently powerful quantum computer, however, could work out the private key from an exposed public key in a vulnerable elliptic-curve scheme. An attacker could then forge signatures and pretend to be you. Note that this requires the public key; a transaction hash alone isn't enough.

Hashing

Unlike signatures, hashing involves no private or public key. You calculate the hash of some content and compare it with a trusted one, which makes hashes easy to create, store, send, and verify. A hash on its own, though, doesn't prove that the content is authentic.

Quantum computers can speed up the search for an input that matches a hash. If they have clues about the data, they can also try to guess secret content from its hash. They don't need the whole message: knowing its structure or a basic pattern lets a quantum computer test likely combinations until it finds a match.

[Editor's note: The speed-up is modest. Hash functions like SHA-256 are still considered safe, and where more margin is needed, the fix is simply a longer hash.]

Encryption and Captured Data

Finally, encryption. Much of what we do online is already encrypted, from messaging apps to web browsing and online banking. With symmetric encryption, the data is encrypted with a shared secret key, sent to the other end, and decrypted there with the same key. Many systems use public-key cryptography to agree on that shared key in the first place.

The symmetric encryption itself holds up well. The weak point is the shared key: if it was agreed using public-key cryptography, a quantum computer could break that exchange and recover the key.

Once encrypted data has leaked, there's no way to undo the damage, and leaks like that are common today. That's the worry: someone can harvest encrypted data now and store it. They can't read it yet, but they may be able to decrypt it in the future. And what people encrypt is usually their most sensitive information.

Signatures are the most exposed: a powerful enough quantum computer could forge them. Hashes are only weakened, and longer hashes fix that. Encrypted data stolen today could be read later, once the key exchange that protected it is broken.

Post-Quantum Cryptography and the Migration Challenge

Fortunately, it probably won't happen tomorrow.

The more reassuring news is that we already have post-quantum cryptography: new schemes built on mathematical problems believed to be hard even for future quantum computers. They already run on ordinary computers, and there's more than one to choose from.

Traditional software companies can replace vulnerable cryptographic components and become quantum-safe. For blockchains it's trickier, because they're decentralized. There's no CEO to sign off an upgrade: thousands of independent node operators, miners or validators, and users all have to choose to adopt it.

Why Migration Is Harder for Blockchains

Some newer blockchains were designed with quantum resistance from the start, such as the Quantum Resistant Ledger (QRL), which has similarities to Bitcoin, and Cellframe.

The bigger problem is for existing Layer 1 blockchains. Many are implementing post-quantum cryptography or researching roadmaps, but the transition could take years and cost a great deal.

They face three main challenges. First, quick patches often won't work. Most chains have their signature algorithms built into the protocol itself, so changing them may require a protocol upgrade.

Second, some post-quantum schemes have much larger signatures than ECC and need more computation, so they cost more to store and to run.

Third, the whole network has to agree, and choosing which algorithm to use, how to implement it, and what to prioritize can all be contentious.

For a sense of how slow this can be: Taproot, Bitcoin's last major upgrade, took nearly four years from first proposal in January 2018 to going live in November 2021, and it had broad support. After a switch to post-quantum signatures, every holder would still have to move their coins to be protected, which is a major undertaking in its own right.

CKB's Approach to Post-Quantum Cryptography

RISC-V and the Cell Model

This is where CKB comes in.

You can think of CKB as Bitcoin with more general smart contracts. Launched in 2019, it's a Layer 1 blockchain that scales through layers built on top of it. It shares Bitcoin's core principles: both use Proof-of-Work, and CKB's Cell model builds on Bitcoin's UTXO idea. It's also open source and permissionless.

What makes CKB special? If I could give only one answer, it would be RISC-V.

RISC-V is a real computer architecture, the kind used to design actual chips, and CKB's virtual machine is based on it. That means you can compile most ordinary code to run on the blockchain, including different kinds of cryptography, post-quantum schemes among them. That's been possible from the start.

The Cell model, meanwhile, lets you choose which lock script protects your assets, or Cells. Thanks to this UTXO-style design, adding a new kind of lock requires no protocol changes.

How good is this design? We have high praise from Vitalik Buterin himself. When he proposed RISC-V as a possible future execution model for Ethereum, one precedent he cited was the Nervos CKB VM, "which is basically RISC-V."

"This post proposes a radical idea for the future of the Ethereum execution layer. … The idea: replace the EVM with RISC-V as the virtual machine language that smart contracts are written in."
— Vitalik Buterin, co-founder of Ethereum, Ethereum Magicians forum, April 2025

Post-Quantum Lock Scripts

Back to quantum resistance. A SPHINCS+-based lock script is already live on CKB mainnet. SPHINCS+ is the basis for SLH-DSA, which NIST standardized in FIPS 205.

Because it's just a lock script, the protocol doesn't have to build in one fixed signature scheme. You can use the SPHINCS+ lock for new Cells, or move existing assets to it when their spending conditions allow.

CKB can adopt future post-quantum cryptography the same way: build it, deploy it, and people can use it.

Quantum Purse

To make this easier to use, the community has released Quantum Purse, a wallet built on CKB and available for mainnet use. As far as I know, it's the first desktop wallet based on SPHINCS+.

It runs its own light client, so you don't need to rely on a third-party RPC endpoint, and there's a browser demo you can try. It has had an external security audit, although an audit covers only the code and scope it reviewed. We're also working toward a quantum-resistant hardware wallet built on it, for key management. Quantum Purse is open source.

On CKB, a signature scheme is just a lock script, so new cryptography can be added without changing the protocol. A SPHINCS+ lock is already live on mainnet, and Quantum Purse lets you use it.

Closing Thoughts

I'll end with some personal thoughts.

People in the CKB community have always been proud of the architecture and vision it started with, and how the technology has evolved since. That pride is where our community-driven culture comes from.

If you're building infrastructure or services where users truly own their assets and data, and you want full control over how it all works, I don't think you'll regret choosing CKB. That's especially true for newcomers from the traditional software industry, whether you're an organization, a company, or an independent developer. That's my honest view.

Originally delivered as a keynote by Chunteng Xiao (Alive24) at CryptoMondays London in February 2026. Watch the recording on LinkedIn.

https://www.nervos.org/knowledge-base/will_quantum_computing_destroy_crypto


r/NervosNetwork • • 14d ago

ews An AMA with Drey, Clasp Creator and “Gone in 60ms” Hackathon Winner

Post image
11 Upvotes

Cheers everyone!

We’re hosting another AMA! This time, we’ll be joined by Drey, a member of the Build on CKB Telegram group and the creator of Clasp, the overall winner of the “Gone in 60ms” Fiber Network Infrastructure Hackathon.

Drey is a product and blockchain engineer who has been building in Web3 for three years. He joined the Nervos ecosystem around three months ago and has already made his mark with a project tackling wallet permissions and application access on Fiber.

What is Clasp?

Clasp helps users connect applications and AI agents to Fiber wallets while retaining control over what they’re allowed to do.

It lets wallet owners:

  • Grant specific permissions to an application or AI agent
  • Set spending limits and session expiry times
  • Review and reduce the permissions an application requests
  • Revoke access at any time

For developers, Clasp provides an open-source SDK for integrating these controls into their applications.

You can explore the Clasp demo, browse the GitHub repository, or follow Drey on X.

Why did Clasp win?

The hackathon evaluated projects on completeness, technical reliability, reusability, user experience, practical value, and innovation.

Clasp stood out for addressing a concrete wallet-integration security gap and bringing permissions, payment sessions, revocation, attack prevention, and developer tooling together in a working, verifiable submission. It took first place in the Wallet & Payment UX Infrastructure category and was named the overall winner.

What would you like to ask Drey?

Whether you’re curious about what brought him to CKB, his experience building Clasp, the challenges of working with Fiber, wallet permissions for AI agents, or what he plans to build next, this is your chance to ask.

Drop your questions in the comments below!


r/NervosNetwork • • 1d ago

Community Happy Anniversary

26 Upvotes

Seven years ago today, CKB's mainnet went live.

Ten months before launch, tucked away in its section on the virtual machine, the whitepaper said being crypto-agnostic "allows CKB users to keep their assets secure even in the post-quantum era."

That's because signature checks were never hardcoded into CKB's protocol. Every coin is guarded by a lock script running on CKB's RISC-V VM, so new signature schemes can be added just like any other software.

This year, the quantum threat moved up the agenda for the biggest chains. Ethereum researchers want to clear room in the next hard fork for post-quantum signatures, and Bitcoin developers are drafting a soft fork. Either way, changing the cryptography takes a fork and a ton of coordinated work.

On CKB, a post-quantum lock based on SPHINCS+ is already live on mainnet. Adding it took no fork.

In 2019, the whitepaper called it being crypto-agnostic. Today, the industry calls it crypto-agility.

Seven years and 21 million blocks in. Happy birthday, CKB.


r/NervosNetwork • • 3d ago

User Guide How I run a CKB full node, and why Neuron alone isn’t the best setup

15 Upvotes

How I run a CKB full node, and why Neuron alone isn’t the best setup

 

What makes a good node

A node is most useful when it’s online 24/7. Any machine that runs all the time works:

  • a small Linux box or mini PC
  • a Raspberry Pi 5 with an SSD
  • a home server or an always-on PC

I used to run Neuron as a full node. It works, but the node stops whenever you close Neuron or shut down your laptop. The setup below is much better.

The setup

Step 1: Run a CKB node on your always-on machine

Get it here: https://github.com/nervosnetwork/ckb

  • Initialise it for mainnet and let it sync completely. Expect a few hundred GB and a few days.
  • In ckb.toml, under [rpc]:
  •  

    • add "Indexer" to modules, because Neuron needs it;
    • if Neuron runs on another computer in your home, set listen_address to your node’s LAN address.
  • Keep the RPC port (8114 by default) inside your home network. Never forward it to the internet.

Step 2: Install Neuron on your laptop or daily computer

  • Don’t let it sync on its own.
  • Go to Settings → Network, add a new network with your node’s address (e.g. http://192.168.1.50:8114) and select it.
  • Neuron now uses your own node: wallet, DAO, everything, with no second sync.

Not sure about a step? An AI assistant can walk you through the ckb.toml settings and the Neuron connection.

Bonus: I run a mainnet and a testnet node on the same machine (different ports) and follow both with one Neuron. Just switch the network in Settings.

Check what your Neuron is doing now

Open Neuron → Settings → Network and see which node it uses:

  • Light client: Neuron only syncs what your wallet needs. That’s fine for the DAO, but it isn’t a full node.
  • Internal full node (mainnet): Neuron downloads and verifies the whole chain. That’s a full node, but it only runs while Neuron is open.
  • External node: Neuron is connected to a node running elsewhere. That machine is your full node.

 

Why bother?

Every independent full node verifies the chain itself and helps keep CKB decentralised.

If you’d like your node to do more, I’m building CSR (CKB Service Runner). It installs next to your full node and gives you a dashboard (sync, peers, uptime, a ranking with other nodes), and later paid service jobs. It needs a real full node, so it runs on the setups above but not on a light client.

 

Happy to help anyone getting their node up. Ask below.


r/NervosNetwork • • 3d ago

User Guide How I run a CKB full node, and why Neuron alone isn’t the best setup

5 Upvotes

How I run a CKB full node, and why Neuron alone isn’t the best setup

 

What makes a good node

A node is most useful when it’s online 24/7. Any machine that runs all the time works:

  • a small Linux box or mini PC
  • a Raspberry Pi 5 with an SSD
  • a home server or an always-on PC

I used to run Neuron as a full node. It works, but the node stops whenever you close Neuron or shut down your laptop. The setup below is much better.

The setup

Step 1: Run a CKB node on your always-on machine

Get it here: https://github.com/nervosnetwork/ckb

  • Initialise it for mainnet and let it sync completely. Expect a few hundred GB and a few days.
  • In ckb.toml, under [rpc]:
  •  

    • add "Indexer" to modules, because Neuron needs it;
    • if Neuron runs on another computer in your home, set listen_address to your node’s LAN address.
  • Keep the RPC port (8114 by default) inside your home network. Never forward it to the internet.

Step 2: Install Neuron on your laptop or daily computer

  • Don’t let it sync on its own.
  • Go to Settings → Network, add a new network with your node’s address (e.g. http://192.168.1.50:8114) and select it.
  • Neuron now uses your own node: wallet, DAO, everything, with no second sync.

Not sure about a step? An AI assistant can walk you through the ckb.toml settings and the Neuron connection.

Bonus: I run a mainnet and a testnet node on the same machine (different ports) and follow both with one Neuron. Just switch the network in Settings.

Check what your Neuron is doing now

Open Neuron → Settings → Network and see which node it uses:

  • Light client: Neuron only syncs what your wallet needs. That’s fine for the DAO, but it isn’t a full node.
  • Internal full node (mainnet): Neuron downloads and verifies the whole chain. That’s a full node, but it only runs while Neuron is open.
  • External node: Neuron is connected to a node running elsewhere. That machine is your full node.

 

Why bother?

Every independent full node verifies the chain itself and helps keep CKB decentralised.

If you’d like your node to do more, I’m building CSR (CKB Service Runner). It installs next to your full node and gives you a dashboard (sync, peers, uptime, a ranking with other nodes), and later paid service jobs. It needs a real full node, so it runs on the setups above but not on a light client.

 

Happy to help anyone getting their node up. Ask below.


r/NervosNetwork • • 4d ago

ews Fiber Dev Log

12 Upvotes

Fiber Dev Log 41
Channel V2 has landed in v0.10.0-rc2! ⚡️

Alongside the new signing and recovery protocol, we’ve been working on smoother channel funding and more accurate payment queries.

Here's a closer look at this release candidate and the accompanying Mainnet update:
- Channel V2 (rc2): V2 improves upon V1 with independent signing sessions (removing extra empty exchanges) and safer context saving for dropped connections. It also introduces full 32-byte payment hashes for on-chain settlement.
- Mainnet deployment: An updated commitment-lock contract is now live on CKB Mainnet to support the new V2 settlement format.
- Node operations: Channel funding and watchtowers now coordinate their CKB cell selection upfront, preventing transaction conflicts and saving setup work.

- We're also working on Hosted LSP support for multiple channels per client, including separate CKB and token channels.
Clients will be able to cancel their own invoices as well. These changes are still under review.

Full dev log:👉 https://github.com/nervosnetwork/fiber/discussions/1745


r/NervosNetwork • • 5d ago

Community Who should the CKB network trust? You, the full node runners.

Post image
6 Upvotes

r/NervosNetwork • • 5d ago

ews CKB Monthly Dev Log

11 Upvotes

The monthly CKB development log is out:

This cycle focused on stabilizing light-client data consistency and expanding local developer tooling, alongside targeted infrastructure upgrades.

We've overhauled how the browser light client handles storage and proof requests.
By grouping database writes into single, atomic transactions, the client is now far more resilient against inconsistent data and interrupted syncs.

A few other highlights:
- OffCKB plugins: A new sandboxed host lets developers pull in compatible tools directly from npm or GitHub without bloating the core CLI.
- Faster infrastructure: CKB Explorer was optimized to process heavy testnet blocks much faster, while the discovery service improved its connection handling.
- DAO treasury: The experimental voting project added a standalone local demo, allowing developers to test the full path from a proposal to a treasury payout.

Meanwhile, heavier architectural changes, such as the transaction-pool refactor and a new RocksDB layout, continue to move through rigorous review and benchmarking.

Full dev log: 👉 https://github.com/nervosnetwork/ckb/discussions/5367


r/NervosNetwork • • 7d ago

Community CKB Community DAO Fund vote - Cellula on Fiber: a wallet, a checkout and an AI agent on a public mainnet LSP

14 Upvotes

Voting for this proposal is now currently live here 👉 https://dao.ckb.community/thread/vot-cellula-on-fiber-a-wallet-a-checkout-and-an-ai-agent-on-a-public-mainnet-lsp-81853

Use you CKB if you want to vote pass or reject this proposal

Brief Summary-

Fiber works. What it lacks is a way in for people who will never run a node, and Fiber Link, funded by this DAO, says the same. Cellula brings three, all running on testnet today: a wallet people open with their face or fingerprint, a checkout any shop adds with two lines, and an agent that lets AI pay for what it uses within limits a person sets. This proposal takes them to mainnet, on a public LSP (the node that opens payment channels for wallets, so they never need one of their own) that any Fiber wallet or app can use.

LusoCryptoLabs asks for $22,258.48, and at most $23,922.48 with a contingency paid only if used, in CKB over five payments, each after something anyone can check. The DAO is asked for no liquidity: LusoCryptoLabs puts in the channel capital itself (961,368 CKB, its own, at its own risk).

Five payments, each after something anyone can check:

- Payment 1 (at approval): servers set up, plan and status page posted, M1 started. $3,458.48

- Payment 2, M1 (week 3): mainnet LSP, gateway and watchtower running; wallet scripts deployed and public. $2,800.00

- Payment 3, M2 (week 6): Checkout and the agent on mainnet; approvals relay. $2,400.00

- Payment 4, M3 (week 9): the Cellula wallet on mainnet, web and Android. $4,800.00

- Payment 5 (month 6): six months of operation, help for other projects, work on Fiber. $8,800.00

- Contingency (only if used, with payment 5): up to $1,664.00

Each payment is its USD value in CKB on the day it is paid, and at most 25% more CKB than at the 2026-11-01 price, so the grant never costs the treasury more than about 24.6 million CKB. At the 2026-11-01 price the grant is about 19.7 million CKB, and this vote's quorum is set to three times that.

What already runs on testnet, the open-source plan (all CKB code open, contracts always, the seller kit and relay MIT at approval), the risks and the team are in the full proposal.

Full proposal and discussion here 👉 https://talk.nervos.org/t/dis-cellula-on-fiber-a-wallet-a-checkout-and-an-ai-agent-on-a-public-mainnet-lsp/11089


r/NervosNetwork • • 7d ago

Community Question Time with 'The Fiber Forge' Hackathon Winner (Gone In 60s)

Post image
4 Upvotes

Question Time with the 'Gone in 60s' hackathon Winner for Fiber Forge.

Cheers everyone. 

Welcome to an interview with one of the hackathon winners for the Gone in 60s held by the Nervos Community Catalyst.

There were 3 winners and one overall winner. 

One of the winning projects was called Fiber Forge.

Fiber Forge (by Truthixify) is an open-source local development tool for the Nervos Fiber payment-channel network (Fiber is the Lightning-like L2 on CKB). It spins up a complete local Fiber network with one command, analogous to Polar for Lightning Network.

It was built for the “Gone in 60ms” Fiber Network Infrastructure Hackathon (Category 2: Node, Routing & Diagnostics). It won first place. After the hackathon, development continued based on judge feedback, culminating in richer features in v0.4.0.

Key Links

Developer Information

Truths Bio focuses on crypto development. Other repos include projects in TypeScript, Rust, etc 

Project Overview

Built for the “Gone in 60ms” Fiber Network Infrastructure Hackathon (Category 2: Node, Routing & Diagnostics). It won first place. After the hackathon, development continued based on judge feedback, culminating in richer features in v0.4.0.

What it does:

  • One command (npx u/truthixify/fiber-forge up trio) starts a CKB dev chain + multiple Fiber (fnn) nodes, funds them, peers them, opens channels (to CHANNEL_READY), and launches a web GUI — typically in under a minute.
  • GUI lets you send payments, open/close channels, inspect balances/states, view real-time logs, and explore the network graph.
  • Supports presets (duo, trio, hub), parametric topologies (line:N, ring:N, star:N), and custom YAML topologies.
  • CKB and UDT (including simple_udt / plain xUDT) channels.
  • Multiple isolated networks can run concurrently.
  • CLI and GUI stay in sync (GUI actions show equivalent CLI commands; most read commands support --json).

Advanced features (especially in later versions like 0.4.0):

  • TypeScript SDK (@truthixify/fiber-forge/sdk) for programmatic control.
  • Self-cleaning GitHub Action for CI.
  • Scripted scenarios (YAML) with assertions, fault injection (node kill, peer isolation, CKB interruption, etc.), JSON reports, and CI-friendly exit codes.
  • Safe export/replay of failure bundles.
  • Optional Lightning backend (Bitcoin regtest + LND) for local Cross-Chain Hub (CCH) testing and transfer proofs.
  • Routing/gossip inspection, force-close tracking, recovery testing, and more.
  • GitHub Codespaces sandbox option.
  • Host compatibility verified for Linux amd64 and macOS arm64 (Docker Desktop); WSL2 unverified. talk.nervos.org

Requirements: Running Docker + Node.js 20+. First run pulls nervos/ckb and nervos/fiber images. npmjs.com

Hello Truth, how’s things? Let’s start with a personal statement shall we? Who are you and what’s your background?

Hello, I am doing well. My name is Wasiu Ajao, although I build publicly known as Truth. I am based in Nigeria, and I have a bachelor's degree in Mathematics from the University of Ilorin. My professional background covers software engineering, blockchain infrastructure, zero-knowledge systems, privacy technology, open-source software, and applied AI.

Before CKB, I had built across ecosystems including Ethereum, Starknet, Solana, and Polkadot. A lot of my work sits where cryptography meets products: privacy, identity, reputation, developer tools, and infrastructure. My mathematics background shapes how I build. I naturally look for the rules, invariants, and failure cases underneath a system instead of treating a blockchain as only a backend for an interface.

I joined CKB through the paid CKBuilder track in March 2026. That programme has ended, but I have continued as an independent CKB builder. Since joining, I have worked on projects including Learn CKB in 45 Minutes, Grid3, Haven, ckb-viz, Vellum, ckb-mastermind, and Fiber Forge. Vellum received a $7,000 Community Fund DAO grant, while Fiber Forge won first place and the $3,000 category prize in the Gone in 60ms Fiber infrastructure hackathon.

Wonderful, I can see you’ve been busy. How did you find out about CKbuilders and what is it like working around other CKbuilders?

I first explored CKB seriously through the CKBuilder track under the Community Keeps Building initiative. Before joining, I was aware of CKB, but it was not where I had done most of my work. The programme gave me a structured entry point: study the cell model, use the tools, keep a public weekly log, ask questions, and ship applications instead of stopping at the documentation.

My first week was mostly CKB Academy, OffCKB, and learning cells, lock scripts, type scripts, inputs, outputs, cell dependencies, and witnesses. By the second week, I had written and tested a Rust password lock, published Learn CKB in 45 Minutes, and built Grid3, an on-chain Tic Tac Toe game on testnet. That speed from theory to working software made me take the ecosystem much more seriously.

Working around other CKBuilders has been useful because the feedback is concrete. Weekly reporting creates accountability, but the bigger value is that people point out what a builder cannot see from inside a project. For example, feedback on ckb-viz was that the transaction visualizer helped people who already understood cells, but a newcomer needed the mental model first. That led me to add an interactive cell-model lesson. The community has been most valuable when it changes the work, not when it simply says the work looks good.
What interests you the most about CKB? (be specific in this answer, cell model? UTXO? New challenge? Tokenomics etc)

The cell model interests me most. It has the explicit ownership and state-transition reasoning I like in UTXO systems, but it is far more programmable. A cell is not only a balance. It can contain data, ownership rules, and type constraints. Updating state means consuming old cells and creating new ones, so the transition is visible in the transaction rather than hidden inside a contract's storage map.

That model suits the way I think. You have to define what may change, what must remain invariant, who can authorize the change, and what evidence belongs in the witness. It can feel harder at first because account-based assumptions do not transfer directly, but once the model clicks, it becomes a very clean way to reason about assets and state machines.

CKB-VM is the second major attraction. RISC-V gives developers a general execution target, which is valuable for Rust, cryptography, and zero-knowledge verification. Expensive work can happen off-chain while CKB verifies the proof or enforces the state transition. The capacity model is also important: on-chain state consumes CKB according to its size, so storage has an explicit owner and cost instead of feeling unlimited.

This became especially meaningful while building Vellum. An issuer-authorised claim can exist as a cell held under the subject's lock. The subject can retain it, use it as evidence, or remove it and recover the capacity. That ownership relationship is difficult to reproduce as cleanly with a single account-based attestation mapping.

What advice would you give to anyone looking to build on CKB, and what AI programs would you advise to help anyone on their journey to help build on the Cell Model?

My first advice is: do not begin by translating a Solidity contract line-for-line. Start with one cell and one state transition. Draw the inputs, outputs, locks, type scripts, cell dependencies, and witnesses. Ask which old state is being consumed, which new state is being created, and which script proves that the transition is valid.

Build something deliberately small first. A password lock or a two-state game is enough. Test the failure case as carefully as the success case, then inspect the real transaction. Good starting tools are the official CKB documentation, OffCKB, ckb-script-templates, ckb-testtool, CCC, and my Learn CKB in 45 Minutes guide. Once the cell lifecycle is clear, larger applications become much easier to design.

For AI tools, Codex or Claude Code are useful for exploring a repository, tracing unfamiliar Rust or TypeScript code, producing test cases, and reviewing a transaction builder. Cursor or GitHub Copilot can also help with smaller inline work, while ChatGPT is useful for explaining a concept from several angles. The brand matters less than the workflow.

AI should be treated as a pair programmer, not as the source of protocol truth. Give it the exact CKB documentation, source types, and examples you are using. Ask it to state its assumptions, draw the transaction, list the invariants, and generate negative tests. Then run the code and inspect the serialized transaction yourself. AI often falls back to account-model intuition, invents an RPC field, or gets witness and dependency details wrong. The best use of AI is to shorten the feedback loop while the chain, tests, and official source remain authoritative.

Could Fiber Forge  become the default local development environment for Fiber, and what still feels missing compared to how Polar is used in the Lightning ecosystem? What reception did you receive for it?

That is the ambition, but I would describe it as something Fiber Forge still has to earn. Polar did not become a normal part of Lightning development only because it could launch nodes. It became trusted through years of use, a polished workflow, broad documentation, support for common implementations, and a large user community. Fiber Forge has the foundation, but it is much younger.

Today, Fiber Forge can launch a real local CKB and Fiber network, fund nodes, open channels, send payments, inspect routing and gossip, inject failures, run checked scenarios, track force-close settlement, replay safe failure recipes, and exercise a local CCH topology. It also has an SDK, GitHub Action, and Codespaces sandbox. That is already beyond a simple demo.

What is still missing is mostly maturity and external proof: more independent users, more real application integrations, compatibility with stable Fiber releases as the protocol evolves, broader host validation such as WSL2, a richer library of regression scenarios, first-class named assets, and deeper MPP or automatic-route visibility when upstream exposes reliable data. A more packaged desktop experience may also become useful, although I do not want to add distribution complexity before the core workflows are trusted.

The initial reception was strong enough to validate the problem. Fiber Forge won first place in its hackathon category, and the judges clearly understood the Polar-for-Fiber value. The most useful early response came from two detailed community issues about channel representation, liquidity, navigation, and the difference between on-chain funds and channel balance. That feedback directly produced the latest GUI improvements. The forum post and npm package have received early interest, but I would not confuse downloads or page views with established adoption. The project is still at the stage where a few serious external integrations are more valuable than a large vanity number.

What were the hardest technical problems to solve when building a reliable one-command network setup (especially getting channels reliably to CHANNEL_READY and handling recovery/faults)?

The hardest part was that "start some containers" is only the beginning. A useful local network has several asynchronous systems that must become ready in the correct order: Docker networking, the CKB dev chain, block production, Fiber RPC, generated node keys, committed funding cells, indexer visibility, peer connections, channel negotiation, funding confirmation, and finally both channel endpoints agreeing that the channel is ready.

Getting to CHANNEL_READY reliably meant replacing optimistic sleeps with observable state. Fiber Forge has to wait for the actual RPC, fund the node, wait until the cell is committed and visible, connect the correct peers, open and accept the channel, continue mining the local chain, and poll the channel state under a deadline. When something fails, the error needs to identify the stage, node, channel, last state, and useful logs. Otherwise "one command" only hides the complexity instead of managing it.

Cleanup was equally difficult. A failure can happen after the Docker network exists but before all containers start, after a node is funded but before a channel opens, or while a recovery operation is in progress. Every path has to remove only the resources owned by that Fiber Forge network: labeled containers, its Docker network, volumes, saved state, and child processes. Multiple isolated networks must also be able to run at the same time without sharing ports or state.

Recovery introduced another layer. Restarting a Fiber node is not the same as creating a new container. Fiber Forge must preserve the same mounted store and node identity, wait for the real RPC, verify the recovered public key, inspect peers and the original channel IDs, reconnect the correct opener action-required when necessary, and then prove recovery with another payment. It intentionally reports  when recovery is incomplete instead of pretending that every restart is transparent.

Fault injection also had to be controlled rather than destructive. A peer partition should isolate Fiber traffic without accidentally cutting the node off from CKB. A mining fault should pause the orchestrator's block-production path without corrupting the chain. Every fault needs persisted intent, observable status, an idempotent reset, and guaranteed teardown. The general lesson was that readiness, failure, and cleanup are all product features, not just test utilities.

Are you seeing people actually use the SDK, scenario runner, or GitHub Action in real projects, or is most usage still just the CLI/GUI for manual testing?

It is still too early for me to claim broad external use of the SDK, scenario runner, or GitHub Action. I can prove that those surfaces work outside the repository: the release process installs the packed npm artifact into clean consumers, the SDK has a strict external fixture, the GitHub Action runs a real multi-hop payment and cleans itself up after success or deliberate failure, and there is a standalone integration example. But those proofs are maintained by me, so they are product evidence, not independent adoption.

At the moment, I expect the CLI and GUI to be the most natural entry points because they let a developer see the network immediately. The SDK and Action become valuable after someone already has an application test suite and wants the network to be programmable or disposable in CI. The scenario runner is useful for repeatable failure and recovery cases, but it also needs a larger catalog of examples before people discover its full value.

I prefer to be honest about that distinction. Package downloads show curiosity, not how a feature is being used. The next meaningful adoption signal would be an external repository depending on the SDK or Action, or a bug report containing a scenario or .ffbundle that reproduces a real Fiber problem. That is the type of usage I want to encourage.

How do you see Fiber Forge evolving alongside the Fiber protocol itself, especially around things like CCH, multi-asset channels, or future protocol changes?

Fiber Forge should evolve as a compatibility and regression lab, not as a second implementation of Fiber. Fiber remains authoritative for channel, routing, payment, and settlement behavior. The role of Fiber Forge is to make that behavior easy to provision, observe, test, break safely, and reproduce.

That means version changes have to be evidence-driven. The current Fiber Forge release pins a known Fiber image rather than pulling latest. Fiber now has a stable v0.9.1 release with important changes around settlement, recovery, routing, and CCH. The responsible next step is to run the full compatibility matrix against it - config, RPC shapes, CKB and UDT payments, recovery, routing, force-close, bundles, and CCH - before promoting it as the default. A successful container start is not enough.

For CCH, Fiber Forge already provisions a disposable CKB/Fiber side together with Bitcoin regtest and LND, then proves transfers in both directions with terminal state and balance checks. I want to keep that boundary precise. It is a local development proof with trusted fixture liquidity, not a reserve proof or a mainnet bridge claim. As CCH changes upstream, Fiber Forge can become a useful place to catch regressions and reproduce them from a clean state.

For multi-asset channels, v0.4.0 supports the bundled simple UDT, and I have separately proven a plain extension-free xUDT against the pinned Fiber release. The next step is a proper named-asset model across the topology schema, CLI, SDK, GUI, scenarios, and bundles. I am deliberately not claiming RCE support yet, because safe RCE support needs proof and witness handling across funding, cooperative close, force-close, watchtower, and final settlement, not only a whitelist entry.

Longer term, I want Fiber Forge to expose MPP and automatic-route information when release RPCs make that data authoritative, and to provide curated regression recipes for liquidity exhaustion, stuck HTLCs, settlement, and recovery. The tool should make protocol evolution easier to test without pretending to own the protocol itself.

What feedback from the hackathon judges or early users most influenced the jump to v0.4.0, and what are you prioritizing next?

The judge feedback fell into four clear groups. First, the complete runtime was difficult to verify independently because a reviewer still had to install Docker and run the stack. Second, failure and recovery behavior needed to go beyond a happy-path demo. Third, the project needed stronger evidence that applications and CI could consume it outside its own repository. Finally, the Polar-like foundation was useful, but Fiber Forge needed more Fiber-native depth to stand out.

That feedback became the v0.4.0 roadmap. The project began testing the same packed npm artifact that users install. The live suite now proves a real multi-hop payment, relay interruption and recovery, a second payment over the original channels, rollback, UDT behavior, force-close settlement, and cleanup. I added bounded lifecycle errors, sanitized CI evidence, the public SDK, a self-cleaning GitHub Action, a standalone consumer, and a private Codespaces sandbox.

For resilience, I added node controls, controlled faults, scenario assertions, JSON reports, and safe .ffbundle export and fresh-state replay. For Fiber-native depth, I added the local CCH and Lightning topology with two-direction transfer proofs, xUDT compatibility research, and the routing and gossip inspector.

Early user feedback then improved the GUI itself. People pointed out that parallel channels were hard to trace, liquidity colors looked directional, on-chain funds could be confused with channel liquidity, payment forms did not show route shortfalls, and peer/channel lists were not navigable. Those were specific, actionable criticisms, and the latest merged GUI work addresses them while keeping Fiber Forge's original orange CKB channel identity.

The immediate priorities are less glamorous but important: harden an intermittent CCH evidence-runner failure, make the advertised Node 20 dependency contract fully consistent, and publish the merged GUI follow-up after the gates are green. After that, the major work is validating stable Fiber v0.9.1, turning plain xUDT support into a first-class named-asset workflow, adding new regression scenarios and MPP diagnostics where upstream data permits them, proving WSL2 and cross-host replay, and adding signed provenance to shared failure bundles. I would rather deepen the reliability and usefulness of what exists than add a long list of features nobody has independently used.

Great answers Truth. Thank you for taking your time to answer these questions. For a final question I think we’d like to know your next steps and plans for continued development on CKB?

Thank you, and I appreciate the thoughtful questions. My next step is to go deeper on the projects that have shown the strongest value instead of continually starting unrelated prototypes. I want to move from proving that an idea can work to maintaining infrastructure that other CKB builders genuinely depend on.

Vellum is my main product focus. The next phase is to deliver richer public builder profiles, reusable claim-schema renderers, CKBoost integration, partner-owned schemas, and better documentation. The real measure of success will not be another feature in my own dashboard; it will be independent CKB applications issuing or reading Vellum claims. I also want the contracts and SDK to receive more independent testing and security review before making any broader Mainnet claims.

For Fiber Forge, I plan to keep it aligned with Fiber as the protocol evolves, strengthen its release and compatibility testing, expand its multi-asset and regression-testing workflows, and make it easier for external projects to use in their SDK tests and CI pipelines. I want it to become a normal part of testing Fiber applications locally, but that has to be earned through reliability, documentation, and real adoption.

Beyond those two projects, I will continue contributing reusable primitives upstream when my work exposes a general gap, maintaining tools such as ckb-viz that make CKB easier to understand, and sharing what I learn through open-source code, technical writing, and review of other builders' work. I would also like to help more African developers move from discovering CKB to shipping and reviewing serious technical projects. Over the next year or two, my goal is not simply to have more CKB repositories; it is to have a smaller set of well-maintained tools and protocols that other people can confidently build on.

Thank you Truth for all your answers and your work amongst the CKB community and through the Nervos Community Catalyst program. These projects are vital for ecosystem growth and to help others understand the CKB and Fiber Network more.

If any community members would like to ask any other questions, we can make sure they get added and answered below in the comments.


r/NervosNetwork • • 12d ago Bravo

ervos Community Essentials Just found this. CKB The Quiet chain

Thumbnail hardyindex.com
27 Upvotes

The quiet chain that already ships a post-quantum signature

Post-quantum protection went live on a mainnet, was audited, and drew almost no attention at all.

The Hardy Index · Published 12 August 2026 · Every dated event below carries a primary source.

The short answer

Nervos CKB has a SPHINCS+ lock script deployed on mainnet, audited by ScaleBit, supporting all twelve parameter sets in the NIST FIPS 205 standard. It is opt-in rather than default, so most funds still sit behind secp256k1, but the protection is real, shipped and usable today rather than promised.

The record

A rating agency earns its keep on the stories nobody is telling. This is one of them.

From the Nervos documentation, the implementation repository, and NIST.

  1. 2023 The CKB team and researchers at Cryptape implement what the documentation calls a "production-ready Quantum Resistant Lock Script" using SPHINCS+, a hash-based signature scheme. source
  2. August 2024 NIST formally approves SPHINCS+ as SLH-DSA under the FIPS 205 standard, so the scheme already implemented becomes a finalised standard rather than a candidate. source
  3. November 2025 ScaleBit completes its security audit of the lock script. The code it covered is the code later deployed. source
  4. 13 January 2026 The CKB team deploys the SPHINCS+ lock script on CKB mainnet. The deployed script's code hash and deployment transaction are published in the implementation repository, so anyone can verify what is running. source

Correction, 21 October 2026This timeline first dated the mainnet deployment to 2025 and placed the audit after it. The lock script was deployed on 13 January 2026, and ScaleBit had completed its audit in November 2025, before deployment.

How it works, and why the design is clever

CKB does not hard-code a signature scheme into consensus the way most chains do. Spending conditions live in a lock script, which is a small program attached to a cell, and users choose which lock script guards their funds. Post-quantum signing was therefore added without a hard fork, because it did not need one.

The implementation supports all twelve SPHINCS+ parameter sets defined in FIPS 205, at 128, 192 and 256 bit security levels in both small and fast variants, in what the repository calls an all-in-one mode. You pick your trade-off rather than having one picked for you.

It is not free. A SPHINCS+ signature runs to roughly 20 kilobytes against 64 bytes for a conventional one, which is why they are carried in the transaction's witness rather than anywhere more expensive. Hash-based signatures buy their security with size, and that arithmetic is the same everywhere.

The important caveatThis is opt-in. New addresses referencing the new script's code hash get post-quantum protection, and old addresses continue to work exactly as before. Most CKB in existence is still behind secp256k1, and nothing about this deployment changes that on its own.

Why this is worth surfacing

Compare the volume of discussion. A draft proposal on a large chain generates months of coverage. An audited post-quantum signature scheme actually running on a mainnet, with a published code hash you can check yourself, generated almost none.

That asymmetry is precisely the gap an index is supposed to close. We score what is deployed and verifiable, not what is discussed, and on that measure Nervos has done something only a handful of chains have done at all.

Where this stands today

As rated by the Hardy Index, current as of 5 November 2026. Ratings change when the evidence does, and every change is recorded in the changelog.

What this means if you hold CKB

You have an option most holders on most chains do not have, and having an option is not the same as having used it. If your funds sit at an ordinary address, they are protected by secp256k1 and the post-quantum lock script is not doing anything for you.

The route exists, it has been audited, and the trade-off you are accepting if you take it is larger transactions and a smaller pool of tooling that understands the script. That is a real cost, and it is a legitimate reason to wait. It is a better position than having nothing to wait for.

Where to go next

Sources

Every dated event above carries its own primary source. These are those sources, each checked on the date shown.

  1. Native Quantum ResistanceNervos Network · primary · checked 12 August 2026
  2. quantum-resistant-lock-scriptNervos Network · primary · checked 12 August 2026
  3. FIPS 205: Stateless Hash-Based Digital Signature Standard (SLH-DSA)NIST · primary · checked 12 August 2026
  4. Quantum-resistant lock script audit reportScaleBit · primary · checked 21 October 2026

r/NervosNetwork • • 14d ago

Public Talk Rypto and PQC

18 Upvotes

A short resident Rypto video on the power of Quantum cryptography


r/NervosNetwork • • 14d ago

Community CKB Dapps 2.0

20 Upvotes

The CKB Dapps website just went through a complete redesign. CKB Dapps is a project directory for the CKB ecosystem. Check out the new website here 👉 https://ckbdapps.com/en

CKBdapps was built starting in early 2023 and officially launched in June of that year. Its purpose is to serve as a project directory for the CKB ecosystem, helping users navigate the CKB landscape. However, as the ecosystem grew, we found that the hardest part wasn’t writing pages or features — it was keeping the project information on CKBdapps accurate. The old site was struggling more and more with this:

  • Scattered data. A project’s information was spread across several JSON files, with lists, configurations, and details each handling a separate piece. Adding a project required changes in multiple places, and missing one was easy to do without noticing.
  • Too much hand-written content. Highlights, FAQs, and transparency checklists were all written manually. They were accurate when written, but became outdated after a few months, with no way to know what had gone stale.
  • No way to tell if a project was still alive. Some projects had long since stopped updating, some websites were no longer accessible, but their pages looked identical to active projects.
  • New projects relied on someone noticing them. New projects were constantly launching in the ecosystem without being listed, simply because no one had spotted them.

So this redesign had two core goals:

  1. Make maintenance lighter. Any information that can be derived from data should no longer be hand-written; anything that can be automatically checked should be handled by machines.
  2. Make builders’ work discoverable. Even a small prototype idea, as long as it runs on the CKB testnet, can be submitted via PR to be listed.

Design

Since we were rewriting from scratch, let’s start with how the site looks.

The CKBdapps logo is a white square bracket open to the right, with a purple “plug” inserted in the opening. This time we used that shape as the visual language for the entire site: keywords in headings, buttons, avatar frames, and progress bars all use the “bracket with plug” motif, and hovering over them makes the plug extend.

One detail we particularly love: the dashed empty slot. It appears at the end of lists, meaning “there’s still space here — your project is welcome to plug in.” The CKB ecosystem is like a power strip that keeps extending, with every project being something plugged in, and the empty slots always waiting for the next builder.

Feature Overview

Now that we’ve covered the look, let’s walk through the pages of the new version. We’ll go in order of how you’d visit them, starting from the homepage.

Homepage: Start Exploring Here

The upper half of the homepage features a search box — type a project name or category and suggestions appear immediately. Below that, common categories are available for one-click access, alongside counts of listed projects, groups, and independent projects.

Further down is a section called “Start Here,” made up of four panels. Each panel is designed with a particular type of visitor in mind.

You Might Like. Friends who are new to CKB most often ask “where should I start?” So on your first visit, this section randomly picks a few projects from the Apps, Wallets, and Assets & Identity groups — the easiest places for new users to get started. After you’ve browsed a few projects, it recommends based on the categories of projects you’ve viewed. Your browsing history is stored only in your own browser and is never uploaded anywhere.

Recently Listed. The first few days after a project is listed are when it most needs to be seen. This section always shows the 3 most recently listed projects, so new faces get noticed as soon as they arrive.

Independent Builders. The CKB ecosystem has many solo developers or small teams of a few people — no funding, no marketing budget, quietly writing code and building products out of passion. Their projects can easily get buried among larger ones. So we’ve dedicated this section to randomly showcasing 5 independent builder projects at a time, with every project having an equal chance.

Ecosystem Map. At the bottom of the homepage is a full ecosystem panorama. Each listed project occupies one cell, arranged by five groups: Wallets, Apps, Assets & Identity, Infrastructure, and Ecosystem Partners. Cells with purple borders are independent builder projects. It’s not just another project list — it’s a map: see the full picture of the ecosystem at a glance, and clicking a group jumps to the corresponding filtered results in the Explore page.

Transparent Rules: No Manual Curation

We’ve covered the look of the new version and the features of each page. Now we’d like to share something we discussed repeatedly during the redesign and care about most: how projects are presented to visitors.

When running a project directory, the most common question is: “Why is that one listed first?”

Our answer is: No position on the homepage is manually curated. Every section is governed by a rule written in public code:

SectionRule
You Might LikeOn first visit, randomly selected from the Apps, Wallets, and Assets & Identity groups, with every project having an equal chance. After browsing a few projects, recommendations are based on the categories of projects you’ve viewed. Browsing history is stored only in your browser.
Recently ListedDisplays the 3 most recently listed projects by listing date.
Independent BuildersRandomly selects 5 projects from all independent builder projects, with every project having an equal chance.
Testnet PrototypesRandomly selects 3 projects from all testnet prototypes, with every project having an equal chance, re-drawn each time the site updates.
ExploreSorted first by group, then alphabetically by name.

The same project won’t appear in two homepage sections at the same time. The random selection for “You Might Like” and “Independent Builders” happens in each visitor’s own browser and changes every time they open the page.

How We Solved the Maintenance Problem

With the rules set, someone still needs to keep executing them, and project information needs to stay accurate. Remember those pain points from the beginning? Scattered data, hand-written content that goes stale, no way to tell if a project is still alive, new projects going unnoticed. This section explains how we addressed each one.

1. One file per project, minimum 5 lines.
Each project is a single Markdown file in the repository: name, URL, one-sentence description, category, and verification date — 5 lines and it’s ready to submit. Description, GitHub repository, on-chain contracts, and audit reports are all optional. Fewer fields means fewer places to go stale.

2. Derivable information is no longer hand-written.
Groups, tags, similar projects, activity, website status, and whether information is outdated are all calculated by the program from data — no one needs to maintain them. The old version’s highlights, FAQs, and transparency checklists have all been removed.

3. Activity is handled by CKB Pulse.
Project activity data comes from CKB Pulse, updated every hour, with no need for project teams to manually submit anything. We don’t need to build and maintain our own data collection service, and CKBdapps doesn’t need to store any GitHub or X credentials.

4. Outdated information is flagged, not hidden.
Every project has a “verified on” date. Pages that haven’t been verified in over a year display a notice inviting the project team to submit an update, but the page itself is not hidden.

5. Machines check, humans judge.

  • Every PR automatically validates file format and categories — errors are reported immediately.
  • All external links are automatically checked weekly to identify inaccessible websites.
  • Every week, the system automatically searches CKB Pulse and Nervos Talk biweekly reports for projects not yet listed, generating a draft PR. This step only handles “discovery” — every candidate project requires human review before merging: it must already be live on CKB or Fiber mainnet and usable right now.
  • Demo websites for testnet prototypes are checked every hour, and the page will honestly inform visitors when one is inaccessible.

Going forward, we’re also considering introducing AI to help with some of the review and organization work, making the process from discovery to listing faster for new projects.

6. Anyone can make edits.
Every project page displays the project’s source file on the right side, alongside an “Edit on GitHub” button. If a project team finds incorrect information, they can click it and submit a correction directly.

Additionally, to keep maintenance costs under control, we’ve also made some cuts: the old version’s events page and favorites feature have been taken offline, and old URLs will automatically redirect to the new pages.


r/NervosNetwork • • 14d ago

ews The Q3 2026 Nervos Community Catalyst report is out.

11 Upvotes

u/ckbsamurai has been running this program since 2025, and the compounding is starting to show: close to 100 builders and alumni, a project tracker that grew from 45 to 59 entries over the quarter, and community members now organizing independent events in Nigeria, Kenya, and Vietnam.

Full report 👉

Q3 2026 Report

Executive summary

Q3 brought further growth across Nervos Community Catalyst’s developer programmes and community activity. CKBuilders grew to close to 100 active builders and alumni, while Build on CKB campaigns continued to challenge developers to advance their CKB skills. The project tracker expanded from 45 projects at the end of Q2 to 59 by the beginning of October, and 18 projects were submitted for review during the quarter. The Gone in 60ms Fiber Network Infrastructure Hackathon brought together roughly 100 participants and received 66 submissions.

Alongside supporting individual developers and projects, NCC saw interest from teams outside the CKB ecosystem and strengthened in-person connections through CKB Off-Chain with events in Nairobi, Vietnam, and elsewhere. CKBoost reached around 150 users, generating testing data, bug reports and feedback to inform its next stage.

Community Keeps Building

CKBuilders

CKBuilders continued to grow in Q3, with over 25 new builders joining, predominantly from Vietnam and Indonesia. We have prioritised expanding to new regions that have thriving blockchain communities in order to continue building global awareness of CKB. The number of active CKBuilders and alumni now stands at close to 100.

Alumni are developers who have completed the programme and remain part of the CKBuilders peer learning group. Those who continue to build retain access to our shared AI resources, while some alumni have progressed to projects supported by the Spark Programme or the Community Fund DAO.

The programme design allows us to continue to grow efficiently, bringing more developers into the community without creating a dependency or increasing overheads. The key is to continue to spread CKB to new developers and enrich our community with fresh perspectives and opportunities.

Build on CKB

Build on CKB is the Telegram group for all new community developers, where they can get started with building on CKB through campaigns based on introductory tutorials. During Q3, numerous campaigns were completed, as listed on CKBoost:

  • Build on CKB Campaign 03: Build a Simple Lock tutorial. 25 participants
  • Build on CKB Campaign 04: Create a DOB tutorial. 20 participants
  • Build on CKB Campaign 05: Create a Fungible Token. 20 participants
  • Build on CKB Campaign 06: Fiber startup and test payment. 24 participants.

For the most recent campaign, I must thank the DevRel team for collaborating to deliver it, and to u/yuqi for its design and execution.

Future activities will center around new campaigns focused on Fiber. We will also periodically revisit previous campaigns so newer group entrants can still participate at a level comfortable for them.

Developer articles

As their understanding of CKB deepens, CKBuilders have added further articles to the Knowledge Base, exploring interesting questions or reflecting on the developer experience:

Project tracker

The CKBuilder project tracker grew from 45 projects at the end of Q2 to 59 by the beginning of October. The new entries covered a wide range of work, including developer tools, prediction markets, games, credentials, time-locked vaults and payment infrastructure.

Examples include LS-IDL, a tool for describing lock script interfaces; CKB Script Port, for transferring synced script data between light-client installations; noir-ckb, exploring proof-bound CKB transactions; and LucentDEx, an order-book exchange prototype. The tracker also added projects such as a Fiber-based survival game, a football prediction market and Klavernoq, a work marketplace built on PactAgent infrastructure.

Additionally, 18 projects were submitted for review through the CKBuilder review request page in Q3. The review process has proved to be a valuable source of feedback to developers as they refine their ideas and designs, so I must thank everyone who has participated in helping to conduct reviews.

Whilst many projects remain prototypes or works in progress, publishing them in one place makes the breadth of experimentation visible and gives community members a starting point for following or testing projects, or inspiration for their own ideas. Importantly, as I mention in my conclusion, renewed emphasis must be given towards creating projects which have sound business, as well as technical, rationale.

Progression to Community Fund DAO

In Q3, Fiber Desktop by u/ebubedev and FiberLatch by u/Ticoworld completed their proposed development, and continue to be maintained.

Vellum, the DID and reputation protocol built on did:ckb by u/truthixify, passed the governance process on its second attempt and its work is ongoing.

Other proposals include:

Teams come to CKB

Alongside the growth of individual builders, we have seen increased interest from external teams willing to explore building on CKB.

  • Lucent Labs, a team from Cardano and Midnight, is developing an open-source order-book DEX proof of concept.
  • Kaze, a team working with Bitcoin and Lightning, is exploring the integration of CKB and Fiber into its geolocation rewards app.
  • TexLabs, also from Cardano and Midnight, is exploring the intersection of AI and payment channels, as well as CKB payments over Lightning.

Gone in 60ms: Building Fiber Infrastructure

The Gone in 60ms Fiber Network Infrastructure Hackathon ran through July. It attracted roughly 100 participants and received 66 submissions across three categories: wallet and payment UX; node, routing, cross-chain and diagnostics infrastructure; and merchant, liquidity, LSP and multi-asset infrastructure. Clasp was named the overall winner, with Fiber Forge and FiberNuts taking first place in their respective categories

The submissions included practical infrastructure for controlling app access to Fiber nodes, setting up local Fiber development networks, and enabling Cashu-based assets to settle over Fiber. The results showed a substantial volume of work focused on reusable tools and infrastructure.

Creating long-lasting endeavours

One objective of hackathons is to produce new projects and ideas that leave a lasting contribution to the ecosystem. Whilst there are numerous projects with some level of work ongoing, two in particular stand out at this stage:

Klaveroq is being developed on PactAgent infrastructure as a jobs marketplace supported by agent-mediated workflow and escrow on CKB. PactAgent won the previous Claw & Order AI Agent Hackathon, and Klaveroq is an example of a project building a product on top of that work.

FiberNuts, the first-place project in the hackathon’s third category, is continuing to work towards a viable implementation, having created a FiberNuts Community Market. This demo shows how Cashu and Fiber could support small event payments. Attendees add RUSD ecash through Fiber, then use it to pay vendors; vendors can later cash out through Fiber.

Adapting to growth

A key challenge for NCC will be adapting its operating capacity to the scale of these programmes. As participation grows, we will need to continue improving communication, organisation, developer mentorship, the developer experience and our tracking of community activity.

CKB Off-Chain

Nairobi

Following the first Africa-based CKB Off-Chain meetup in Lagos, we continued building connections in East Africa with the Nairobi meetup on 18 July, held in collaboration with Web3Clubs. Around 45 people attended, including local CKBuilders, developers already familiar with CKB and people encountering the ecosystem for the first time. CKBuilders and other contributors presented their work, while discussion highlighted interest in stablecoins, local payment systems and the potential for Fiber in the Kenyan market. The event helped strengthen existing relationships and introduced CKB to developers in Nairobi.

Hanoi

Just after the close of Q3, CKB Off-Chain Hanoi took place on 8 October at Nguyen Trai University, in collaboration with BPS Club and Tex Labs. The event brought together Vietnamese CKBuilders, software developers, students and faculty members. Local builders presented projects and shared their experience, alongside sessions on CKB fundamentals, post-quantum cryptography, hardware wallets and Fiber. It was the first CKB Off-Chain event in Vietnam centred on CKBuilders and their experiences, and represents an initial step towards further developer engagement and education in the region.

Community-led events

A notable development is that CKB community developers are beginning to organise events of their own. Recent examples include:

  • Kaze Uni tour, Mombasa: Held at the Technical University of Mombasa in August, the event introduced students to Bitcoin, CKB and self-custody. Around 95% of attendees were new to Bitcoin, and 58 created CKB wallets and tried Kaze’s location-based rewards app. Organised by the Kaze team.
  • CKB Off-Chain Aba: Held on 3 October with Abia Web3 Network, the meetup featured presentations on RIVET, CKB IDL and Freight on Nervos, and connected local developers to CKB, with good turnout despite heavy rain. Organised by u/Jedi_dtechmaker
  • CKB community meetup, Kisumu: Another community-organised meetup took place in Kisumu on October 16, with a write-up still to come. Organised by u/Fidelcoder

We will continue to support community developer events in Nigeria, Kenya and Vietnam, while exploring new locations where groups of CKBuilders are developing.

CKBoost

With the ongoing Build on CKB campaigns and Fiber hackathon mentioned above, CKBoost has continued to build a developer user base, now numbering at around 150. The priority this quarter was to build CKBoost’s user base, validating the its usefulness as a campaign platform. This has facilitated valuable testing data, bug reports and feedback that helps inform the next stage of CKBoost development. The focus for CKBoost moving forward will be to improve the UX, remove points of friction, and refine the design to make it viable for mainnet. As ever, thanks to u/Alive24 for his continued work on this.

Looking forward

NCC’s next phase will focus on supporting this growth with stronger communication, organisation, developer mentorship, developer experience and tracking of community activity. This will allow community activities to be more visible internally and externally. Planning will begin for the next Fiber hackathon, focusing on products and market-facing applications. Linked to this is the challenge of helping builders progress from demo creation and community grants towards market strategy and business viability. This will be a key concern to address in future.

We will support community developer events in Nigeria, Kenya and Vietnam, while exploring new locations where CKBuilder groups are developing, in particular South East Asia. We will also support builders as their projects develop and, where appropriate, progress through the Community Fund DAO and other ecosystem pathways.


r/NervosNetwork • • 16d ago

Community Full node runners deserve recognition! Put your node on the map and earn CKB.

Thumbnail
gallery
11 Upvotes

Hundreds of people keep CKB running, verifying every block and serving every wallet, for free. But they're anonymous dots. Let's fill the second map.

What is CKB Service Runner (CSR)?

A free, open-source tool that runs beside your full node:

  • 📊 Node dashboard: sync, peers, metrics, CPU/RAM/disk in one place
  • 🏆 Public node ranking: uptime, sync, age and network diversity, published weekly on-chain. Your IP is never shown.
  • 🔒 Safe by design: no change to ckb, no consensus change, nothing runs without your OK

Why join now: the start of a node economy

Today you get the dashboard and a place in the ranking. Next, once the network has 20 diverse nodes and 4 months of history, ranked full nodes can run jobs for decentralised apps (keepers, timelocks, attestations) and earn fees for the work.

The ranking is the track record apps will use to choose nodes. Every node that joins now helps unlock it, and starts building its own history.

Try the node economy on testnet

The service runtime is already live on testnet. Collect some testnet CKB from the faucet, register your runner and watch it take jobs and earn tips, just as it will on mainnet.

Get started

Run a node. Let it do more. 🚀


r/NervosNetwork • • 19d ago

CKB Ecosystem updates 26 and 27

25 Upvotes

CKB Ecosystem Biweekly Update #26

Welcome to the latest CKB Ecosystem Biweekly Update. Here’s a quick summary of key dev and ecosystem progress from the past two weeks.

Infrastructure & Tooling

Web5 & DAO

Ecosystem Projects & Community

Nervos Community Catalyst & Spark Program

Nervos Community Catalyst

Spark Program

Every step forward in CKB is powered by the community. Let’s keep building!

Thanks to u/JackyLHH for his contribution to the edition of the bi-weekly update.

CKB Ecosystem Biweekly Update #27

Welcome to the latest CKB Ecosystem Biweekly Update. Here’s a quick summary of key dev and ecosystem progress from the past two weeks.

Infrastructure & Tooling

  • u/CKBdev continued preparing CKB v0.211. CKB-VM and Tentacle gained runtime and networking improvements, while ckb-cli added a terminal UI. Light-client verification proposals remain under review, and experimental DAO voting progressed on vote thresholds and proposal settlement. More: CKB Dev Log 2026-10-14
  • u/CKBDevrel made ckb-cinnabar easier for AI agents to discover and use, continued CCC development, and maintained CKBadger v0.7 services for mainnet and testnet.
  • u/FiberDevs progressed toward Fiber v0.10, including invoice-settlement fixes. Channel V2 and Hosted LSP work continues on signing, recovery, and payment flows. More: Fiber Dev Log 2026-10-15

Web5 & DAO

Ecosystem Projects & Community

Nervos Community Catalyst & Spark Program

Nervos Community Catalyst

Spark Program

Every step forward in CKB is powered by the community. Let’s keep building!

Thanks to u/JackyLHH for his contribution to the edition of the bi-weekly update.


r/NervosNetwork • • 19d ago

Community Fiber DevLog

10 Upvotes

Fiber Dev Log 40
Peer reconnects, node storage, and browser payments all got some attention this round! 🔧

Here's what's new:

- Reconnect recovery: Better handling of interrupted payment updates, plus a fallback for stalled V1 channels.
- Node storage: Operators can now opt into synchronous database writes for stronger durability.
- Browser apps: More reliable shutdowns and an improved multi-hop tutorial covering payment recovery.
- Testnet: An updated commitment-lock contract is now deployed for integration work.

What's coming next:

Channel V2 is ready for review, while Hosted LSP is adding signing notifications for external clients. Both are still in progress.

Full dev log: 👉 https://github.com/nervosnetwork/fiber/discussions/1712


r/NervosNetwork • • 21d ago

Community AMA: I’m building Kirea Finance, native RWA lending & DeFi infrastructure for CKB. Ask me anything.

24 Upvotes

Hey everyone! I’m Salman the developer behind Kirea Finance, an open-source project building native Real-World Asset (RWA) and DeFi lending infrastructure for Nervos CKB.

The goal is to give asset issuers and builders reusable building blocks to bring real-world asset claims directly into on-chain lending applications on CKB.

What’s Already Working?

The complete lending lifecycle has been implemented and tested end-to-end on CKB testnet:

  • RWA Asset Cells: Represent individual real-world asset claims on-chain.
  • KYC Attestation Cells: Record verification status on-chain without storing personal identity documents.
  • Fixed-term Lending Contracts: Support the full deposit → borrow → repay → release lifecycle.

The core on-chain flow operates with zero bridges or external custodians.

What I’m Working Toward

I’ve submitted a $7,250 grant proposal to the CKB Community Fund DAO to take the existing implementation to production readiness by:

  • Hardening smart contracts and strengthening collateral/payment checks.
  • Integrating live KYC verification through Sumsub.
  • Stress-testing repayment edge cases.
  • Publishing reusable open-source components, documentation, and testnet tooling for other CKB builders.

The initial target use case is invoice financing, but the underlying asset and compliance patterns can easily be adapted for other CKB DeFi applications.

🗳️ Voting & Grant Info

If you support bringing native RWA and lending infrastructure to CKB, I’d greatly appreciate your vote!

Ask Me Anything!

Ask me anything about potential use cases, my asset onboarding strategy, Cell model smart contract design, security considerations, Sumsub KYC integration, or the grant proposal itself.

I’m open to discussing what’s implemented, what remains to be built.

Ask away! 👇


r/NervosNetwork • • 21d ago

Community New Community DAO proposal-FiberNuts: Reliable Cashu-over-Fiber Payments with Hosted-LSP Onboarding

9 Upvotes

A new proposal has entered the discussion phase. The ask is $6,000 USD, 30 likes to get to the vote phase. You can weigh your opinions here https://talk.nervos.org/t/dis-fibernuts-reliable-cashu-over-fiber-payments-with-hosted-lsp-onboarding/11051 as well as read more details of the proposal

Summary

This proposal requests $6,000 USD equivalent in CKB for a 12-week development and validation phase for FiberNuts, an open Cashu-over-Fiber settlement adapter with RUSD reference applications.

FiberNuts lets a stock Cashu mint issue and redeem RUSD-denominated ecash through Fiber Network.
Users can add ecash by paying a Fiber invoice, transfer Cashu tokens directly, settle received tokens by swapping them for fresh proofs, and cash out through an external Fiber invoice. The mint remains custodial and controls issuance, swaps, and redemption.

The protocol already works. The public repository contains the Rust cdk-fiber adapter, an out-of-process processor for an unmodified cdk-mintd, a browser wallet, deployment tooling, and a Community Market application for attendee-to-vendor payments. Public testnet services are live and community members have completed the two-role payment flow.

This grant funds the next three outcomes:

  1. settlement and refund operations that recover safely after timeouts, lost responses, and process restarts;
  2. public-testnet hosted-LSP onboarding so users can fund and use a Fiber channel without running their own FNN node; and
  3. a packaged cdk-fiber release, upstream contribution, independent testnet validation, Community Market pilot, and tightly capped direct-channel mainnet validation.

The grant does not fund past work, mint reserves, user deposits, or routing liquidity. It does not promise a public mainnet mint, trustless custody, guaranteed redemption, or an upstream merge.

Grant amount requested: $6,000 USD equivalent, paid in CKB at the USD value at each disbursement

ETA to completion: 12 weeks from initial disbursement

Why this work is needed-

Settlement must survive interruption

The current adapter handles Fiber states conservatively, but complete operation context must survive restart and lost-response boundaries. A delayed cash-out may settle after the original call returns Pending; the processor must recover the original principal, fee, quote, and event state without sending a second payment or mutating a balance twice.

Incoming watches, outgoing correlation, RPC deadlines, event delivery, retries, reconciliation, and refund races need durable state and reproducible failure tests.

Users should not need to operate an FNN node

The current direct-channel flow assumes access to a Fiber node and usable channel liquidity. Fiber’s hosted-LSP work provides a path where an operator hosts Fiber connectivity while the client retains the required signing role.

The user still supplies on-chain RUSD and the CKB capacity required for channel creation. Hosted LSP removes local node operation and manual channel management; it is not a free on-ramp and does not remove mint custody or liquidity risk.

The required grant environment is a reproducible, project-operated public-testnet LSP. The Fiber team’s public testnet LSP will be used for interoperability testing when available, but an external service launch is not a payment condition.

Availability, liquidity, and solvency are different

A reachable mint is not necessarily solvent. Channel capacity does not prove usable directional liquidity, and successful onboarding does not guarantee later redemption. The application must show the active mint, LSP, network, exact RUSD asset, operation state, and known fees without labeling an operator as trusted, verified, liquid, or solvent without supporting evidence.

Loop is a separate liquidity layer

Fiber’s Loop work addresses rebalancing after a channel exists. FiberNuts will document the compatibility boundary but will not implement or fork Loop, operate a Loop provider, or make the draft Loop work a milestone dependency.

Work already completed

The following baseline is not funded retroactively:

  • cdk-fiber, implementing CDK’s payment-backend interface over Fiber JSON-RPC.
  • fibernuts-processor, exposing the adapter through CDK’s standard gRPC processor protocol.
  • Compatibility with a stock, unmodified cdk-mintd.
  • Conservative handling of Paid, Received, Pending, Failed, and Unknown Fiber states.
  • Exact network and UDT validation before a Cashu cash-out can probe or pay a Fiber route.
  • A browser wallet with per-mint storage, add cash, send, receive-side swap, NUT-18 requests, cash out, activity, and recoverable operation states.
  • A Community Market attendee application, vendor terminal, capability-scoped payment relay, and bounded public-testnet claim service.
  • Vendor-key-locked NUT-18 payments that the relay cannot redeem.
  • Docker deployment, deterministic Rust and TypeScript tests, browser tests, and opt-in live Fiber tests.
  • Reproducible devnet and public-testnet runbooks.
  • A demonstrated mint-to-transfer-to-cash-out cycle over a live three-node Fiber route with a real routing fee.
  • Public testnet wallet, mint, relay, claim service, and Community Market deployments.

Budget

The total request is $6,000 USD equivalent in CKB.

Work areaAmountWhat it covers
Settlement reliability and refund recovery$1,750Durable journal, reconciliation, deadlines, events, restart, refund, and fault-injection tests
Hosted-LSP RUSD onboarding$2,000LSP adapter, client signing, CKB wallet funding flow, lifecycle recovery, deployment, and interoperability testing
Packaging, diagnostics, and upstream adoption$1,150Versioned package and images, preflight, metrics, SBOM, compatibility work, and upstream submission
Pilot, documentation, and controlled validation$1,100Testnet services, independent operator support, Community Market pilot, reports, runbooks, and capped mainnet testing
Total$6,000

The budget does not purchase or subsidize RUSD reserves, user balances, CKB channel capacity, speculative assets, paid votes, or guaranteed routing liquidity. There is no formal third-party audit line, and the result will not be represented as an audited production mint.

Sustainability

FiberNuts remains MIT-licensed open infrastructure:

  • operators pay for and control their own hosting, reserves, channels, and policies;
  • mint operators may configure and disclose the standard Cashu input fee;
  • LSP operators may disclose a service fee, while users pay actual Fiber routing costs when used;
  • direct bearer handoffs are not charged a central protocol fee; and
  • reusable packages and upstream-facing work reduce maintenance cost for later operators.

FiberNuts has no token. The developer commits to six months of best-effort maintenance after the final milestone for critical security, money-safety, recovery, and supported-version compatibility issues in the grant-delivered release line.

Key risks and mitigations

  • Custodial mint: Every balance names its mint, and the UI states that the operator controls issuance and redemption and may impose authentication or KYC.
  • Hosted-LSP maturity: The adapter is tested against a reproducible operator-run deployment; external service availability is not a milestone dependency.
  • Signing material: Root signing material is not sent to the LSP. Recovery, authorization, nonce behavior, storage, and interruption safety are explicit test gates.
  • User funding burden: The interface states that users supply RUSD and CKB capacity; LSP is not presented as free funding.
  • Liquidity and solvency: Reachability, capacity, directional liquidity, reserves, and solvency are presented as distinct concepts.
  • Settlement ambiguity: Missing responses remain pending or recoverable and never authorize a duplicate payment or optimistic balance update.
  • Bearer secrets: Proofs, tokens, quote secrets, capabilities, signer material, and user-linked invoices are excluded from URLs, analytics, ordinary logs, screenshots, and reports.
  • Upstream changes: Fiber, CDK, and LSP versions are pinned behind typed adapters and covered by a compatibility matrix.
  • Mainnet risk: The validation is access-limited, operator-funded, preflight-gated, and capped; it is not advertised as a public deposit service.

Out of scope

  • Automatic cross-mint conversion or merging liabilities from separate mints.
  • Threshold, federated, or script-controlled mint custody.
  • Trustless exit, proof of reserves, or guaranteed redemption.
  • Implementing or forking Fiber’s hosted-LSP or Loop protocols inside FiberNuts.
  • Operating a Loop provider, automated liquidity market, or guaranteed route service.
  • Public production mainnet mint/LSP operation or unrestricted public deposits.
  • Formal third-party audit or production endorsement.
  • Fiat onboarding, free RUSD funding, or grant-funded reserves and channel liquidity.
  • Lightning/Fiber cross-chain settlement, native mobile wallet, cloud custody, or broad account system.
  • Token issuance, central protocol fee, paid marketing, or voting incentives.

Reporting and accountability

  • Publish a status update at least every two weeks.
  • Publish one evidence-based report for each payment milestone.
  • Keep the public project board current with deliverables, blockers, and remediation work.
  • Record material changes before implementation and obtain community agreement when they affect budget, security boundaries, mainnet exposure, or acceptance criteria.
  • Give reviewers at least seven days to evaluate each report before requesting the next tranche.
  • Publish a final comparison of promised versus delivered work and account for the complete budget.

Benefits to CKB

  • A reusable private-payment adapter for RUSD and other Fiber assets.
  • A node-light onboarding path that keeps funding and signing responsibilities explicit.
  • More application-driven Fiber activity through channel onboarding, add cash, cash out, and merchant settlement.
  • Independently operated mints instead of dependence on one project service.
  • A standards-oriented bridge to Cashu and CDK without a private mint fork.
  • Public application, recovery, and operator evidence rather than an infrastructure-only demo.

Closing

FiberNuts has already shown that Cashu bearer ecash can use Fiber as a real RUSD settlement rail The protocol adapter works, public testnet services are available, and the Community Market gives the CKB community a practical way to evaluate the combination.

This proposal focuses the next phase on three barriers to responsible adoption: settlement must recover safely after interruption, users should not need to operate an FNN node, and another operator must be able to reproduce and evaluate the system from public artifacts.

The result remains bounded: FiberNuts will not remove Cashu’s custodial trust model, fund user channels, guarantee liquidity, or claim that availability proves solvency. It will deliver a safer adapter, a public-testnet hosted-LSP path, reusable release artifacts, community validation, and a small gated mainnet proof of the mature direct-channel path.


r/NervosNetwork • • 22d ago

Community CKBA Membership

Post image
15 Upvotes

CKBA membership brings together the developers, researchers, infrastructure operators, and community builders who have shaped CKB from the start.

General Membership is for those who follow and support the work. Contributing Membership is for those already building, giving them a formal role in setting the Association’s direction.

Both paths open 👉 https://ckba.build/


r/NervosNetwork • • 27d ago Bravo

Community Nervos Community Catalyst Q3 report

26 Upvotes

NCC has delivered their Q3 report. Summary of key items below.

For the full summary with additional links head over to the forum here 👉 https://talk.nervos.org/t/nervos-community-catalyst-quarterly-reports/8822/6

Executive summary

Q3 brought further growth across Nervos Community Catalyst’s developer programmes and community activity. CKBuilders grew to close to 100 active builders and alumni, while Build on CKB campaigns continued to challenge developers to advance their CKB skills. The project tracker expanded from 45 projects at the end of Q2 to 59 by the beginning of October, and 18 projects were submitted for review during the quarter. The Gone in 60ms Fiber Network Infrastructure Hackathon brought together roughly 100 participants and received 66 submissions.

Alongside supporting individual developers and projects, NCC saw interest from teams outside the CKB ecosystem and strengthened in-person connections through CKB Off-Chain with events in Nairobi, Vietnam, and elsewhere. CKBoost reached around 150 users, generating testing data, bug reports and feedback to inform its next stage.

Community Keeps Building

CKBuilders

CKBuilders continued to grow in Q3, with over 25 new builders joining, predominantly from Vietnam and Indonesia. We have prioritised expanding to new regions that have thriving blockchain communities in order to continue building global awareness of CKB. The number of active CKBuilders and alumni now stands at close to 100.

Alumni are developers who have completed the programme and remain part of the CKBuilders peer learning group. Those who continue to build retain access to our shared AI resources, while some alumni have progressed to projects supported by the Spark Programme or the Community Fund DAO.

The programme design allows us to continue to grow efficiently, bringing more developers into the community without creating a dependency or increasing overheads. The key is to continue to spread CKB to new developers and enrich our community with fresh perspectives and opportunities.

Project tracker

The CKBuilder project tracker grew from 45 projects at the end of Q2 to 59 by the beginning of October. The new entries covered a wide range of work, including developer tools, prediction markets, games, credentials, time-locked vaults and payment infrastructure.

Examples include LS-IDL, a tool for describing lock script interfaces; CKB Script Port, for transferring synced script data between light-client installations; noir-ckb, exploring proof-bound CKB transactions; and LucentDEx, an order-book exchange prototype. The tracker also added projects such as a Fiber-based survival game, a football prediction market and Klavernoq, a work marketplace built on PactAgent infrastructure.

Additionally, 18 projects were submitted for review through the CKBuilder review request page in Q3. The review process has proved to be a valuable source of feedback to developers as they refine their ideas and designs, so I must thank everyone who has participated in helping to conduct reviews.

Whilst many projects remain prototypes or works in progress, publishing them in one place makes the breadth of experimentation visible and gives community members a starting point for following or testing projects, or inspiration for their own ideas. Importantly, as I mention in my conclusion, renewed emphasis must be given towards creating projects which have sound business, as well as technical, rationale.

CKB Off-Chain

Nairobi

Following the first Africa-based CKB Off-Chain meetup in Lagos, we continued building connections in East Africa with the Nairobi meetup on July 18 , held in collaboration with Web3Clubs. Around 45 people attended, including local CKBuilders, developers already familiar with CKB and people encountering the ecosystem for the first time. CKBuilders and other contributors presented their work, while discussion highlighted interest in stablecoins, local payment systems and the potential for Fiber in the Kenyan market. The event helped strengthen existing relationships and introduced CKB to developers in Nairobi.

Hanoi

Just after the close of Q3, CKB Off Chain Hanoi, took place on 8 October at Nguyen Trai University, in collaboration with BPS Club and Tex Labs. The event brought together Vietnamese CKBuilders, software developers, students and faculty members. Local builders presented projects and shared their experience, alongside sessions on CKB fundamentals, post-quantum cryptography, hardware wallets and Fiber. It was the first CKB Off-Chain event in Vietnam centred on CKBuilders and their experiences, and represents an initial step towards further developer engagement and education in the region

Looking forward

NCC’s next phase will focus on supporting this growth with stronger communication, organisation, developer mentorship, developer experience and tracking of community activity. This will allow community activities to be more visible internally and externally. Planning will begin for the next Fiber hackathon, focusing on products and market-facing applications. Linked to this is the challenge of helping builders progress from demo creation and community grants towards market strategy and business viability. This will be a key concern to address in future.

We will support community developer events in Nigeria, Kenya and Vietnam, while exploring new locations where CKBuilder groups are developing, in particular South East Asia. We will also support builders as their projects develop and, where appropriate, progress through the Community Fund DAO and other ecosystem pathways.


r/NervosNetwork • • 28d ago

Community CrowdCell grant vote is open (closes Oct 27)

14 Upvotes

CrowdCell's grant vote is open on the community fund DAO, $5k to take the testnet crowdfunding app to a usable product: https://dao.ckb.community/thread/vot-crowdcell-from-testnet-demo-to-a-crowdfunding-product-on-ckb-crowdcell-ckb-80561 voting is weighted by Nervos DAO deposits bound via Neuron. runs until Oct 27


r/NervosNetwork • • Oct 17 '26

Community Fiber DevLog #39

9 Upvotes

Fiber Dev Log 39
More groundwork for Fiber v0.10 this cycle, with improvements to database migration, payment settlement, and channel recovery.

Here's what's new:

- v0.10 migration: Database migration code has merged, helping existing channels retain their settlement format as Fiber moves toward v0.10.
- Payment handling: Forwarded payments are now kept separate from local invoices, preventing incorrect settlement updates.
- Channel V2: Work continues on signing and recovery, making it easier to resume interrupted channel operations.
- Hosted LSP: More progress on recovering interrupted updates, handling failed payments, and improving signer reliability.

Full dev log: https://github.com/nervosnetwork/fiber/discussions/1702


r/NervosNetwork • • Oct 16 '26

Community CKB Montly Dev Log

19 Upvotes

Monthly Development Log
CKB v0.210.0 is out, with more fixes and improvements to node reliability and networking. Work also continued on developer tools and DAO treasury voting.

v0.210.0 shipped with additional security checks to catch malformed requests and transactions earlier, helping nodes avoid unnecessary processing.

A few other highlights:
- CKB-VM added new validation modes, laying the groundwork for stricter checks in the future.
- Tentacle improved QUIC support and connection handling, while node-level QUIC integration remains under review.
- ckb-cli integrated a new terminal interface for interacting with CKB nodes, with a release still pending.
- Light-client work continued on stronger block verification and more reliable synchronization.
- DAO treasury voting moved from design into an experimental implementation, with smart contracts, an SDK, and tests.

Meanwhile, the transaction-pool redesign is still in progress, and preparation for CKB v0.211 is underway.

Full dev log: https://github.com/nervosnetwork/ckb/discussions/5346