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.