Africa, April 1, 2026 — We're excited to announce our largest Btrust developer grant cohort to date. Ten outstanding Bitcoin open-source developers have been awarded grants, comprising six starter grant recipients and four open-source cohort members, including two renewals and two promotions from starter to long-term grants.

This cohort also marks a couple of firsts: support for Cashu development, and the inclusion of a dedicated research proposal within the open-source cohort. This builds on our existing support across the stack, from core protocol work to wallets, privacy tools, and user-facing applications.

These developers are working across vastly different critical areas of the Bitcoin ecosystem, from Bitcoin Core and Lightning infrastructure to wallet development, privacy protocols, and payment infrastructure. Their work strengthens Bitcoin’s open‑source foundations while expanding the global community of contributors from the Global Majority.

Starter Grants

The Btrust starter grant provides support for software engineers ready to contribute full-time to open-source Bitcoin development. It allows recipients to explore areas of interest, identify a focus for long-term contributions, and engage deeply with the global Bitcoin developer community with relevant support via mentorship and without financial constraints.

Starter Grant Recipients

Michael Ariwaodo

Project: Cashu

Michael is a software developer based in Nigeria with over four years of experience building financial software systems.

After participating in the BOSS program in 2025, Michael began contributing to the Cashu ecosystem, a Chaumian ecash protocol designed to enable fast and privacy‑preserving Bitcoin‑backed payments.

As our first Cashu developer grantee, his recent work includes improvements to Cashu TS and Cashu Nutshell, the reference implementation of a Cashu mint. His contributions have focused on improving mint reliability, removing obsolete legacy APIs, improving wallet compatibility, and aligning implementations with evolving Cashu protocol specifications.

With the starter grant, Michael will continue strengthening the Cashu ecosystem by improving mint safety and operability, completing the removal of deprecated protocol behavior, and expanding compliance with newer Cashu NUT specifications.

He will also introduce protocol compliance tests, improve cross‑implementation compatibility, and research potential interoperability between Cashu and emerging protocols and technologies such as Ark and Minmo.

Frankline Omondi

Projects: Bitcoin Core, bip353-rs

Frankline is a software engineer based in Kenya with experience in systems programming and open‑source infrastructure development.

He completed the BOSS program in 2025 and has since become an active contributor to Bitcoin Core. His work focuses on fuzz testing, networking, and validation logic within consensus‑critical components.

Frankline has contributed to Bitcoin Core’s fuzz testing infrastructure and QA assets, helping improve coverage and detect potential bugs earlier in the development process. He is also the author of bip353‑rs, a Rust implementation of DNS payment instructions with DNSSEC validation.

Through the starter grant, Frankline will dedicate full‑time effort to expanding fuzz testing coverage across key Bitcoin Core subsystems including P2P networking, net processing, and validation logic.

His work will include designing new fuzz harnesses, running long‑duration fuzzing campaigns to uncover edge‑case bugs, and improving documentation and tooling so that more contributors can participate in Bitcoin’s testing infrastructure.

John Osezele

Projects: Bitcoin Dev Kit (BDK), Rust Payjoin

John is a software engineer based in Nigeria with five years of experience building mobile applications across fintech and security platforms.

He is a co‑maintainer of the bdk‑dart project within the Bitcoin Dev Kit ecosystem. The project provides Dart bindings that allow Flutter developers to build Bitcoin wallets powered by BDK’s Rust implementation.

John has already contributed several improvements to the repository and has also contributed to the Rust Payjoin project as part of his journey into Bitcoin open source.

With the starter grant, John will focus on bringing bdk‑dart to production readiness. His work will include improving the stability of the bindings, maintaining compatibility with upstream BDK releases, and strengthening testing and CI infrastructure.

He also plans to build a complete open‑source reference wallet using Flutter and bdk‑dart to demonstrate how developers can build secure non‑custodial Bitcoin wallets using the toolkit.

Victor Chabunda

Projects: rust‑payjoin, UniFFI‑Dart

Chabunda, also known as Chavic, is a developer based in Zambia with nearly a decade of experience building software across multiple platforms.

He is the author of UniFFI‑Dart and a contributor to the rust‑payjoin project, where his work focuses on improving developer experience through cross‑language bindings and tooling.

Victor has played an important role in making Rust‑based Bitcoin libraries accessible to developers working in other programming languages by building robust Foreign Function Interface tooling and SDK integrations.

Through the starter grant, Chavic will focus on building first‑class .NET and C++ bindings for rust‑payjoin, improving documentation and developer tooling, and continuing development on UniFFI‑Dart.

He will also begin work on a transaction fingerprinting analysis tool that helps wallet developers detect privacy leaks in transaction construction and improve overall wallet privacy practices.

Shehu Muhammad Aliyu

Projects: Payjoin Dev Kit (PDK), Bitcoin Dev Kit (BDK)

Shehu is a software engineer based in Nigeria. He holds a degree in Computer Engineering from Ahmadu Bello University and graduated from the 2025 Btrust Builders Rust for Bitcoiners pathway.

Shehu has been actively contributing to the Payjoin Dev Kit (PDK), a project focused on improving bitcoin transaction privacy through collaborative transaction construction. His work has focused on strengthening persistence, improving code maintainability, and addressing protocol‑level security issues.

His contributions include migrating the Payjoin CLI database from Sled to SQLite for better reliability, fixing a potential session replay vulnerability, and improving time‑handling accuracy to align with BIP‑77 specifications. He has also contributed documentation improvements and developer tooling updates that make the project easier for wallet developers to adopt.

With the starter grant, Shehu will work full‑time on expanding Payjoin adoption across Bitcoin tooling. His work will focus on integrating PDK into the Bitcoin Dev Kit CLI, implementing ASMAP‑based relay and directory selection for improved network privacy, and improving reliability through better fallback mechanisms and testing infrastructure.

Sonkeng Maldini

Project: Bitcoin Dev Kit (BDK), Bitcoin Core

Sonkeng is a software engineer based in Cameroon with more than eight years of experience building complex software systems.

His early exposure to Bitcoin development began while working with custom forks of Bitcoin written in C++. Since then, he has worked on distributed trading systems and open‑source infrastructure projects while steadily contributing to Bitcoin‑related development.

Sonkeng has contributed to several projects including the Bitcoin Development Kit, Rust‑Bitcoin, and the Bisq MuSig protocol. He has implemented multisignature wallet features for MuSig and actively participates in code reviews across multiple repositories.

Through the starter grant, Sonkeng will focus on improving developer experience and contributing to new releases within the Bitcoin Development Kit ecosystem. His work will include maintaining fuzz testing infrastructure, contributing to upcoming BDK features such as DNS payment instructions (BIP‑353), supporting silent payments work, and participating in Bitcoin Core Review Club sessions.

He’s also the lead organizer of BitDevs Yaoundé meetups to help grow Bitcoin developer communities in Cameroon.

Long-Term Grants

The Btrust Open-Source Cohort offers long-term support to established Bitcoin open-source contributors, promoting a collaborative environment for sustained development.

Members receive funding paid monthly in bitcoin, mentorship, and peer support to deepen their work on critical Bitcoin open-source projects.

The cohort model aims to build a resilient, inclusive developer ecosystem, enabling contributors from the Global Majority to make meaningful, lasting impacts on Bitcoin's open-source ecosystem.

Long Term Grant Recipients

Chuks Agbakuru

Project: Lightning Dev Kit (LDK)

Chuks is a software engineer based in Nigeria and a former Btrust starter grant recipient who has become a core contributor to the Lightning Dev Kit ecosystem.

Over the past year he has worked extensively on LDK‑Node, contributing features such as support for human‑readable names through BIP‑353 and improvements to infrastructure stability and code reviews.

With this long‑term grant, Chuks will focus on researching and implementing splice batching for the Lightning Network. This work explores how multiple channel splice operations can be coordinated into a single on‑chain transaction, reducing fees and improving scalability for Lightning service providers.

His work will involve specification research, Rust implementation in rust‑lightning, and integration into LDK‑Node APIs.

Peter Tyonum

Project: Bitcoin Dev Kit (BDK)

Peter is a software engineer and maintainer within the Bitcoin Dev Kit ecosystem. Over the past year as a starter grant recipient, he has contributed extensively to bdk‑cli and related wallet infrastructure libraries.

His contributions include implementing hardware wallet support, persistent wallet configuration, compact block filter support, and upgrades to align with the latest BDK wallet APIs.

During the long‑term grant period, Peter will focus on developing a production‑ready Bitcoin Core RPC client library for BDK. This library will serve as a unified interface for interacting with Bitcoin Core across multiple BDK components.

He will also continue maintaining and expanding bdk‑cli, including adding multipath descriptor support and improving testing and reliability across versions.

Enigbe Ochekliye

Project: Lightning Dev Kit (LDK)

Enigbe is a Lightning developer based in Nigeria whose work focuses on Lightning Network infrastructure and research. She holds a Master's in Energy from the University of Auckland, where she completed graduate-level coursework in multivariable control systems, and a Bachelor's in Mechanical Engineering from Ahmadu Bello University. 

Over the past year she has contributed to the LDK ecosystem through code development, reviews, and technical research. Her work includes improvements to logging infrastructure, chain synchronization features, and infrastructure reliability across LDK components.

Under the renewed long‑term grant, Enigbe will pursue research into distributed control systems for Lightning Network liquidity management. Her work models Lightning as a multi‑agent dynamical system and explores how decentralized controllers can coordinate liquidity distribution across the network.

The project will combine theoretical research with practical implementation inside ldk‑node and simulation environments, contributing both academic insights and open‑source engineering improvements.

Enigbe is the first member of the Open Source Cohort to focus on research, expanding the scope of contribution within the program and highlighting the growing importance of research-driven work in the ecosystem.

Chukwuleta Tobechi

Project: BTCPay Server

Tobechi is an experienced software engineer, active BTCPay Server contributor, and the lead organizer of BitDevs Lagos.

During his previous grant period, he developed several major plugins including the Shopify Plugin V2, the Satoshi Tickets event plugin, and the Mavapay Naira Checkout integration. His work has expanded BTCPay Server’s usability for merchants and businesses around the world.

Through this renewed long‑term grant, Tobechi will continue expanding BTCPay Server integrations across e‑commerce platforms and accounting systems while strengthening the plugin ecosystem.

He also plans to develop additional integrations that support African payment rails and local currencies, helping businesses across the continent accept Bitcoin payments more easily.

Btrust Builders Alumni

Most of the recipients above are alumni of the Btrust Builders program.

The structured learning tracks they completed provided a strong foundation in Bitcoin fundamentals, hands‑on open‑source experience, and sustained mentorship from seasoned contributors.

Their progression from Builders graduates to funded grantees reflects the program’s mission to cultivate high‑potential developers across the Global Majority and prepare them for long‑term, sustainable careers in Bitcoin open source. Each grantee’s journey underscores what focused guidance, community collaboration, and opportunity can achieve when paired with dedication and talent.

Learn more and apply to join the next cohort of the Btrust Builders pathways here.

Applications for Btrust Developer Grants

Btrust developer grant applications are open year-round, with new recipients announced quarterly. If you’re a developer passionate about contributing to Bitcoin open-source development, we encourage you to apply.

Learn more about our grant programs and apply through our website.

Stay updated on our initiatives and future opportunities by following us on X, Nostr, Instagram and LinkedIn.

About Us

Btrust is a non-profit organization with a dedicated mission to decentralize the development of Bitcoin Open-Source Software. Our focus is on fostering developer talent in the Global Majority and supporting the free and open-source Bitcoin ecosystem.

Written by Abiodun Awoyemi

Table of Contents

1. Introduction to BIP326
2. Locktime Fundamentals: nLockTime vs nSequence
3. Fee Sniping: The Threat That Locktime Solves
4. How LockTime Defends Against Fee Sniping
5. The Taproot Connection: How MAST works
6. HTLC vs PTLC: Why Off-Chain Protocols Leak
7. The Privacy Gap: The Problem Before BIP326
8. BIP326: The nLockTime + nSequence Strategy
9. Code Implementation & Analysis
10. Conclusion

Introduction to BIP326

Since Bitcoin’s introduction by Satoshi Nakamoto, its scripting capabilities have evolved significantly. One of the most important upgrades is Taproot, introduced in BIP341, which allows a transaction output to commit to multiple spending conditions simultaneously using a structure known as a Merkelized Alternative Script Tree (MAST).

These transaction outputs are called SegWit V1 or P2TR (Pay-to-Taproot). The P2TR locking script can be unlocked via two distinct paths: a Key Path Spend, which uses an aggregated public key, or a Script Path Spend, where the spending conditions are organised into a script tree used to compute the Merkle root. It is this Taproot architecture that BIP326 builds upon to address a specific and previously overlooked privacy gap in off-chain protocols.

BIP326 defines how wallets should behave when spending Taproot outputs by leveraging the nSequence field in place of traditional nLockTime for anti-fee-sniping protection. The primary motivation is to improve the privacy and fungibility of off-chain protocols such that when on-chain wallets adopt this behavior, a Taproot spend with an nSequence value becomes indistinguishable from an off-chain settlement transaction that uses timelock, making it impossible for a blockchain analyst to tell the two apart.

In modern Bitcoin scripting, what makes BIP326 particularly powerful is that it requires no consensus change and no protocol upgrade; it can be adopted unilaterally by wallet software. By simply mimicking the nSequence behaviour that off-chain protocols already use, on-chain wallets begin contributing to an anonymity set that grows larger with every wallet that adopts it.

Locktime Fundamentals: nLockTime vs nSequence

Bitcoin supports two types of locktimes that control when a UTXO can be spent.

1. Absolute Locktime prevents a transaction from being mined until a specific block height or Unix timestamp has been reached. It is set at the transaction level via the nLockTime field and applies to the entire transaction. Bitcoin interprets nLockTime below 500,000,000 as a block height and at or above 500,000,000 as a Unix timestamp.
2. Relative Locktime defines a delay based on when a specific output was mined, rather than a fixed date or block height. Encoded at the input level via the nSequence field, it allows for granular control over each input independently. This functionality was introduced by BIP68, which repurposed the nSequence field to enable these relative constraints. BIP68 requires transaction version 2 and interprets the lower 16 bits of nSequence as either a block-based or time-based relative delay.

The nSequence field is a 32-bit value assigned to each transaction input. Under BIP68, it is parsed as follows:

1. Bit 31 acts as the disable flag; if set, the relative locktime is ignored.

2. Bit 22 determines the unit, distinguishing between block-height (0) and time-based (1) delays.

3. Bits 0–15, the lower 16 bits store the actual duration, allowing for a maximum value of 65,535 blocks or 65,535 intervals of 512 seconds each.

Bits 16–21 and 23–30 are currently undefined and reserved under BIP68.

Off-chain protocols such as Lightning Network channels and CoinSwaps commonly use relative locktime because they allow contracts to remain open indefinitely.

Since absolute locktime are still used and still necessary, BIP326 does not propose replacing nLockTime entirely, because it is backward compatible. Instead, it proposes that Taproot wallets keep using nLockTime but also frequently use nSequence, alternating between the two with a 50% probability.

Fee Sniping: The Threat That Locktime Solves

Fee sniping refers to the process of re-mining the last block in the chain to claim the fees of both the transactions mined in that block and the new high-fee transactions that entered the mempool since it was mined. Instead of extending the current blockchain, a miner ignores the last block and secretly attempts to mine an alternative version of it. If successful, the original block is orphaned and the attacker collects all its fees, including all other high fee transactions that arrived in the mempool after the original block was confirmed.

Fee sniping threaten two fundamental properties of Bitcoin which are:

1. Settlement finality: when miners can re-mine past blocks, users can no longer trust that confirmed transactions are irreversible. A transaction with 6 confirmations today could be reversed tomorrow, which undermines the basic promise that Bitcoin’s confirmation model makes to its users.
2. Miner incentive alignment: Bitcoin’s security model is built on the assumption that miners are always incentivised to extend the longest chain. Fee sniping breaks that assumption. When re-mining a past block is more profitable than building on the current tip, the economic foundation of the entire network is compromised. In other words, miner incentive alignment is the mechanism Bitcoin relies on, and network security is what collapses when that alignment breaks.

How LockTime Defends Against Fee Sniping

Most wallets set nLockTime to the current block height, ensuring that transactions are only valid in the next block. This prevents miners from reorganizing the blockchain to include high-fee transactions from the mempool into a re-mined past block during fee sniping. By limiting transaction inclusion to the latest block, the fee sniping attack becomes economically unviable. Today, most modern wallet implementations including Bitcoin Core, BDK, and Electrum set anti-fee-sniping locktime by default.

However, while nLockTime effectively prevents fee sniping, it introduces a privacy leak by making on-chain transactions distinguishable from off-chain settlements. BIP326 addresses this by proposing that Taproot wallets alternate between nLockTime and nSequence randomly, using each with equal probability. This provides the same anti-fee-sniping protection while making on-chain and off-chain timelocked transactions indistinguishable, enhancing privacy and fungibility across the network.

The Taproot Connection: How MAST works

The Merkelized Alternative Script Tree (MAST), originally the Merkelized Abstract Syntax Tree, allows a Bitcoin output to commit to multiple spending conditions simultaneously while revealing only what is strictly necessary at spend time. It uses a Merkle tree to summarise the collection of potential spending scripts, avoiding the need to include every script in the transaction while keeping all unused conditions completely hidden on-chain

Think of MAST as a tree where each leaf represents a spending condition or script path. For example, one leaf could be “Alice can spend after 100 blocks,” another could be “Bob and Alice can spend together cooperatively,” and another could be “Bob can spend with a hash preimage”. These leaves are hashed and paired together, working upward until they produce a single Merkle root committed inside the Taproot output. When spent, only the executed leaf is revealed on-chain and all unused script paths remain completely hidden.

In off-chain protocols like Lightning Network, when a channel is force-closed via the timelock path, only that branch is revealed. However, before BIP326, the nSequence value used in that timelock settlement acted as an immediate fingerprint. Regular on-chain wallets were not using nSequence, any nSequence value was an instant indicator of off-chain activity. BIP326 addresses this by formally specifying that all Taproot wallets should randomly alternate between nLockTime and nSequence for anti-fee-sniping protection, making on-chain and off-chain Taproot spends completely indistinguishable.

HTLC vs PTLC: Why Off-Chain Protocols Leak

Hash Time-Locked Contract (HTLC) is a script-based conditional payment constructs that secure payments across multiple hops using a hash lock and a time lock. To claim the funds, the recipient must produce a secret value (the preimage) that hashes to a predetermined hash within a specified timeframe, otherwise the funds are returned to the sender. The critical privacy problem with HTLCs is that the same hash is used across every hop in a payment route, meaning any routing node can correlate the payment end-to-end simply by recognising the same hash value appearing at each step.

Point Time-Locked Contract (PTLC) perform the same function as HTLCs but provide stronger privacy using elliptic curve point operations based on Schnorr Signatures. Instead of a hash preimage, a PTLC requires the recipient to produce a scalar value corresponding to a specific elliptic curve point to claim the funds. PTLCs use a different randomised point per hop, breaking the payment correlation that HTLCs expose and making it impossible for routing nodes to link individual hops into a single payment path.

When a Lightning channel is force-closed and an HTLC must be settled on-chain, the blockchain sees a hash value and preimage. A cooperative close, by contrast, reveals none of this — both parties agree on final balances off-chain and broadcast a simple transaction that looks like any ordinary Taproot spend. When a Lightning channel closes via PTLC cooperatively, the blockchain sees only a regular Taproot script. However, a timelock path closure reveals either OP_CHECKSEQUENCEVERIFY opcode in the script itself or an nSequence ​value in the transaction input.

Note: At the time of writing, the Lightning Network still uses HTLCs. PTLCs are a planned upgrade dependent on broader Taproot and Schnorr Signature adoption across Lightning implementations. BIP326 lays the groundwork today so that when PTLCs are eventually deployed, the anonymity set will already be large enough to provide meaningful privacy.

The Privacy Gap: The Problem Before BIP326

Before BIP326, off-chain protocols such as Lightning Network relied on Hash Time-Locked Contracts (HTLCs) which is script-based conditional payment constructs that, when forced to settle on-chain, revealed recognisable fingerprints that chain analysts could trivially identify and trace.

In a Lightning Network channel, when one party broadcasts their latest commitment transaction without the agreement of the other party, the HTLC is forced to settle on-chain. The transaction reveals recognizable fingerprints which are traceable. Chain analysts could trivially identify these transactions making them simple to spot and analyze. What was intended to be private has now become public.

Privacy in Bitcoin depends on transactions being indistinguishable from one another, when there is a large pool of transactions, it becomes significantly harder to single out any one of them. HTLCs produced a distinct script pattern such as hash preimage, timelock structure and multi-path constructs, that existed almost nowhere else on-chain, making the anonymity set small and unique. At that point, even users who never broadcast their channel activity are exposed and the moment a channel is forced to close, the entire payment history off-chain can become linkable on-chain, and what was meant to be private off-chain becomes an open record on-chain.

BIP326: The nLockTime + nSequence Strategy

BIP326 proposes that Taproot wallets randomly alternate between nLockTime and nSequence for anti-fee-sniping protection, using each with a 50% probability. This random alternation is the core of the strategy. When on-chain wallets behave the same way off-chain protocols do, the nSequence value that once acted as a fingerprint becomes indistinguishable from a regular wallet transaction.

To further protect transactions that may be delayed after signing, wallets should also apply a random look back with a 10% probability, subtracting a random value between 0 and 99 from the current block height. This ensures delayed transactions blend naturally into the broader transaction landscape without standing out as anomalies.

BIP326 does not replace nLockTime, rather it acknowledges that absolute locktimes remain indispensable. There are specific scenarios where nSequence cannot be used and nLockTime must be the fallback:

1. When any input is unconfirmed
2. When any input has more than 65,535 confirmations
3. When any input is not a Taproot output
4. When RBF is not set, because nSequence needs specific values to signal RBF and cannot simultaneously encode both RBF signaling and a relative locktime

In all these cases, the wallet must use nLockTime. nLockTime remains the universal baseline, it is reliable, broadly applicable and backward compatible, while nSequence is the privacy upgrade specifically for eligible Taproot transactions.

Code Implementation & Analysis

The following implementation is written in Rust in the bdk_tx crate. It applies BIP326 anti-fee-sniping protection to a transaction by randomly alternating between nLockTime and nSequence for eligible Taproot inputs. The implementation takes a mutable transaction, a slice of inputs, the current block height, RBF flag, and a random number generator as parameters.

Before any logic runs, a guard clause checks that the transaction version is at least 2, which is a requirement of BIP68. If the version is less than 2, the function returns a CreatePsbtError::UnsupportedVersion error immediately and halts execution.

if tx.version < Version::TWO {
    return Err(CreatePsbtError::UnsupportedVersion(tx.version));
}

The implementation then filters all inputs to identify eligible Taproot inputs, specifically those whose previous output script is a Pay-to-Taproot (P2TR) script. Non-Taproot inputs are excluded entirely because BIP326 is specifically scoped to Taproot outputs only.

let taproot_inputs: Vec<(usize, &Input)> = tx
    .input
    .iter()
    .enumerate()
    .filter_map(|(vin, txin)| {
        let input = inputs
            .iter()
            .find(|input| input.prev_outpoint() == txin.previous_output)?;
        if input.prev_txout().script_pubkey.is_p2tr() {
            Some((vin, input))
        } else {
            None
        }
    })
    .collect();

Next, the function evaluates whether any input forces a fallback to nLockTime. Three conditions trigger this fallback, each for a specific reason. An unconfirmed input forces the fallback because confirmations() == 0 means nSequence cannot encode a meaningful relative delay. An input exceeding 65,535 confirmations forces the fallback because nSequence only has 16 bits for block-based delays and the value would overflow. A non-Taproot input forces the fallback because BIP326 is explicitly scoped to Taproot inputs only.

let must_use_locktime = inputs.iter().any(|input| {
    let confirmation = input.confirmations(current_height);
    confirmation == 0
        || confirmation > MAX_RELATIVE_HEIGHT
        || !input.prev_txout().script_pubkey.is_p2tr()
});

If none of these conditions are met, the function uses a 50/50 random coin flip to decide between nLockTime and nSequence. Worth noting here is the !rbf_enabled condition, which forces nLockTime when RBF is disabled. This is because using nSequence for anti-fee-sniping on a non-RBF transaction could accidentally signal RBF, since RBF is indicated by nSequence values below 0xFFFFFFFE.

let use_locktime = !rbf_enabled
    || must_use_locktime
    || taproot_inputs.is_empty()
    || random_probability(rng, FIFTY_PERCENT_PROBABILITY_RANGE);

A unique aspect of BIP326 is the 10% lookback rule, with 10% probability, the locktime is set slightly in the past (up to 99 blocks back), rather than exactly at the current block height. This preserves privacy for transactions that are signed but broadcast with a delay. For example, transactions routed through high-latency privacy networks. Without this, a transaction signed offline and broadcast later would stand out because its locktime would be noticeably behind the current chain tip.

For the nLockTime path:

if use_locktime {
    let mut locktime = current_height.to_consensus_u32();

    if random_probability(rng, TEN_PERCENT_PROBABILITY_RANGE) {
        let random_offset = random_range(rng, MAX_RANDOM_OFFSET);
        locktime = locktime.saturating_sub(random_offset);
    }

    let new_locktime = LockTime::from_height(locktime)
        .expect("must be valid Height");
    tx.lock_time = new_locktime;
}

For the nSequence path, the same 10% lookback logic applies, but with an additional .max(MIN_SEQUENCE_VALUE) guard to ensure nSequence never reaches zero, which would disable the relative locktime entirely under BIP68. The saturating_sub call prevents integer underflow when subtracting the random offset from a small confirmation value.

else {
    tx.lock_time = LockTime::ZERO;
    let random_index = random_range(rng, taproot_inputs.len() as u32);
    let (input_index, input) = taproot_inputs[random_index as usize];
    let confirmation = input.confirmations(current_height);

    let mut sequence_value = confirmation;
    if random_probability(rng, TEN_PERCENT_PROBABILITY_RANGE) {
        let random_offset = random_range(rng, MAX_RANDOM_OFFSET);
        sequence_value = sequence_value
            .saturating_sub(random_offset)
            .max(MIN_SEQUENCE_VALUE);
    }

    tx.input[input_index].sequence = Sequence(sequence_value);
}

It is also worth noting that BIP326 protection is opt-in by design. In PsbtParams, the enable_anti_fee_sniping flag defaults to false, meaning wallet implementers must explicitly enable it. This reflects two deliberate design decisions working together: it avoids silently modifying transaction behaviour for callers who have not opted in, and it preserves full backward compatibility, ensuring that existing wallets and integrations continue to behave exactly as before without any forced migration.

pub enable_anti_fee_sniping: bool,
// Defaults to false

The implementation supports both std and no-std environments through conditional compilation.

Conclusion

BIP326, though simple in its mechanism, is profound in its implications. By randomly alternating between nLockTime and nSequence for anti-fee-sniping in Taproot transactions, it closes the last remaining forensic gap that chain analysts could exploit to identify off-chain protocol settlements on-chain. The privacy impact is a network effect, every Taproot wallet that adopts BIP326 enlarges the anonymity set that off-chain protocols like Lightning Network and CoinSwap depend on, improving fungibility and security for the entire ecosystem.

What makes BIP326 significant is that it requires no consensus change, no protocol upgrade, and no coordination between nodes. It is a wallet behaviour standard that any implementation can adopt. The anonymity set BIP326 depends on only grows if wallets act before Taproot usage patterns become entrenched.

BIP326 is not just a wallet policy recommendation, it is a foundational privacy primitive that the entire Bitcoin Layer 2 ecosystem depends on, and its full impact will only be realised as Taproot adoption, PTLC deployment, and wallet implementation converge toward a more private, fungible, and scalable Bitcoin.

References

1. https://github.com/bitcoindevkit/bdk-tx 
2. https://github.com/bitcoin/bips/blob/master/bip-0326.mediawiki 
3. https://learnmeabitcoin.com/technical/upgrades/taproot 
4. https://bitcoinops.org/en/topics/htlc 
5. https://www.bydfi.com/blog/learn/glossary/merkelized-alternative-script-tree-mast 
6. https://www.wallstreetmojo.com/hashed-timelock-contract 
7. https://bitcoin.stackexchange.com/questions/120922/what-is-fee-sniping

At its core, Bitcoin is sustained by people; developers who review code, fix bugs, debate tradeoffs, and quietly maintain the software that powers a global monetary network.

In 2025, Btrust’s support of open source development efforts were guided by a belief that when developers from Africa and the Global Majority are given sustained support, they can become long‑term stewards of Bitcoin’s open‑source infrastructure.

Towards the end of 2024, we welcomed a new Engineering Lead, marking a shift from early experimentation to deliberate scaling. In 2025, this translated into stronger systems, clearer expectations, and deeper technical engagement, all designed to support developer grantee impact.

This leadership transition catalysed significant structural improvements across two key programs:

• Btrust Builders Program: Our hands-on, technical training arm that mentors new African software developers and helps them make their first contributions to Bitcoin open source development.
• Btrust Grants Program: A support system for developers actively contributing to Bitcoin open-source projects, as well as events, conferences, and educational initiatives that deepen the Bitcoin open-source contributor ecosystem.

H1 2025: Foundation And Structural Improvements

The first half of 2025 focused on improving the systems that support developer grantees, from onboarding to funding decisions.

Strengthening The Developer Pipeline

Developers need time, mentorship, and structured learning environments to meaningfully contribute to Bitcoin's open-source ecosystem.

The Btrust Builders program serves as an important entry point into that pipeline, helping aspiring developers gain the technical foundations required to eventually contribute to Bitcoin open source projects and qualify for developer grants.

In 2025, Btrust Builders supported 493 developers across our five technical pathways, with more than 1,800 applications received from across Africa and beyond.

In addition, the launch of our first Open-Source Bootcamp marked a major milestone for us, where 40 top graduates from the Mastering Bitcoin and Bitcoin CLI pathways gained hands-on experience contributing to Bitcoin open-source projects including Bitcoin Core, BDK, Polar, BlueWallet, Rust-Payjoin, and BTCPay Server.

For a deeper look at the program structure and outcomes, read the full 2025 Btrust Builders year in review blog.

Reimagining The Btrust Developer Grants Process

We also restructured our grant review process by introducing clearer requirements and establishing a dedicated sub‑committee of experienced Bitcoin open‑source contributors.

This change reduced average review time from 4 months to under 2 weeks, making it easier for developers to access timely support, and brought greater transparency, consistency, and fairness.

H2 2025: Scaling And Deepening Impact

The second half of the year focused on optimising our processes and expanding opportunities for our highest-performing grantees.

Two of our long-term grantees, both Bitcoin Core contributors, under the Btrust Pull Partnership, were invited to the 2140 office in Amsterdam to gain experience working alongside other Bitcoin Core developers. We believe collaborative partnerships like these help bridge geographic distances in open-source communities and ensure that voices from the Global Majority are part of Bitcoin’s core technical evolution.

Meanwhile, our collective grantees made their own mark, authoring over 200 PRs across 15 Bitcoin open-source projects and publishing 7 articles on our blog, covering topics ranging from personal journeys into Bitcoin open-source to Bitcoin Core protocol development.

2025 Grantee Impact By The Numbers

Program Growth And Ecosystem Expansion

2025 was a significant year of growth for the Btrust developer grantee program, both in the number of contributors supported and the Bitcoin open-source projects they contributed to. Active grantees (starter and long-term) grew from 5 to 18, representing a 260% increase over the previous year.

At the same time, the program's geographic footprint expanded beyond its strong base in Nigeria to include Kenya, Uganda, Morocco, and Egypt, reflecting a growing pool of open-source Bitcoin talent across the continent.

Alongside this growth in contributors and geography, grantees also expanded the range of projects they contribute to. In 2025, Btrust grantees were actively contributing to 15 Bitcoin open-source projects spanning multiple layers of the Bitcoin stack, including protocol development, scaling infrastructure, privacy tools, and end-user applications. These projects include:

• Protocol/Base Layer: Bitcoin Core, Rust-Bitcoin, BDK, BDK-CLI, BitcoinJ
• Scaling Solutions: LDK Node, LDK Server, LND, Stratum V2, Polar
• Privacy & Wallets: BlueWallet, Payjoin, Coinswap, BTCPay Server, VLS

Aggregate Performance Metrics

Performance across all 15 projects for the 2025 period:

High-Impact Project Spotlights

The impact of our grantees was felt across multiple layers of the Bitcoin stack, from protocol improvements to end-user applications and the following sections highlight the specific projects, and technical areas where these contributions had the most impact.

Bitcoin Core Contributions

Our grantees represent a significant portion of the specialized workforce contributing to Bitcoin's base layer.

Key Metrics

• 364 PR reviews performed on Bitcoin Core, directly addressing the protocol's well-known review bottleneck
• 52 PRs merged with 43 commits
• 12 PRs currently open

Contributions Breakdown

• 7 New Features
• 15 Bug Fixes
• 12 Test Improvements
• 4 Refactors
• 5 Documentation Updates

Highlights of Bitcoin Core Contributions

• Schnorr Batch Verification: Eunovo implemented batch verification of Schnorr signatures, significantly improving validation speed
• Silent Payments: Eunovo integrated Silent Payments into Core; a major advancement for on-chain privacy. Sending and receiving support now available on Bitcoin Core GUI
• Mempool-Based Fee Estimation: Abubakar Sadiq Ismail introduced new fee estimation logic to reduce overestimation during volatile market periods
• Code Review of various projects (Cluster Mempool, Libbitcoinkernel and Mining interface)
• Bug fix: Abubakar Sadiq Ismail resolved an issue in the Bitcoin Core block template assembler.
• Brandon Odiwuor fixed TestShell initialization issues caused by symlinks resolution.
• Brandon added unit test to handle case where the CLI returns an empty string, ensuring it is correctly interpreted as None in RPC tests.
• Brandon made several CI updates, including:
  • Updating the asan-lsan-ubsan-integer-no-depends-usdt workflow to use the Mold linker for faster builds.
  • Removing bash -c from the CMake invocation and replaced it with eval for cleaner command execution.

Lightning Development Kit (LDK)

• Bitcoin Core Chain Synchronization: Enigbe integrated Bitcoin Core as a chain data backend via its REST API, enabling full block-level synchronization and providing node operators with an alternative to third-party Esplora/Electrum indexers.
• Configurable Logging Infrastructure:  Enigbe built a pluggable logging system targeting different backends, and giving integrators full control over observability in deployments.
• Multi-tier Data Storage Architecture:  Enigbe implemented a tiered KVStore system that separates critical channel state, ephemeral data, and disaster-recovery backups across independent storage backends, enabling safer, more flexible deployment.
• BIP-353 Integration: Chuks integrated BIP-353 into LDK-Node. This significantly improves usability by making it possible to securely send payments to Human-Readable Names.
• Replace-By-Fee (RBF) and Event-Driven Transaction Management: Rita rebuilt payment store synchronization from full-transaction polling to BDK's wallet event stream, then leveraged this event-driven architecture to implement fee-bumping (RBF) for unconfirmed on-chain transactions and automatic background rebroadcasting with configurable attempt limits.

LND (Lightning Network Daemon)

Work on LND included contributions aimed at improving usability, reliability, and development stability. Abdullahi Yunus contributed to several improvements, including:

• UX Improvements: Added pagination to wallet transactions
• RPC Updates: Updates to RPC, including an extension to pathfinding for routes and a tracking addition to htlc forwarding events.
• Persistence: Ensured node announcement configurations persist across restarts. Added a second-layer backup for channels via archives.
• Test Flakes: Participated in hunting and addressing various CI flakes

Validating Lightning Signer (VLS)

Contributions were also made to Validating Lightning Signer (VLS), focusing on reliability, security, and operational efficiency. Sulaiman Aminu Barkindo worked on several improvements, including:

• Infrastructure and Reliability: Led critical persistence layer upgrade from Redb 1.5 to 2.2.0 with seamless automatic migration, ensuring zero-downtime upgrades for production deployments across vls-persist and LSS components.
• Security and Fund Safety: Enhanced fund recovery and security by implementing comprehensive second-level HTLC tracking, fixing sweep transaction vulnerabilities in unilateral close handling, and establishing anchor channel recovery infrastructure for zero-fee HTLC channels.
• Performance Optimization: Streamlined core operations by eliminating redundant commitment validation checks and optimizing monitoring to track only spendable HTLCs, reducing resource overhead.
• Team Collaboration: Accelerated delivery through code reviews across multiple critical PRs in a small, high-impact team.

Bitcoin Development Kit (BDK)

Peter Tyonum worked on several enhancements to BDK, including:

• Hardware Wallet Support: Added native hardware wallet support to the BDK binary crate, demonstrating how users can bridge the gap between mobile apps and cold storage
• Worked on a minimal, experimental Bitcoin Core RPC client  for the Bitcoin Dev Kit (BDK), with a focus on data emission and strict type safety, with built-in support for multiple Bitcoin versions
• Added wallet config subcommand, which allows users to persist wallet configurations to a local configuration file for ease and reuse, improving the UX of the binary crate
• Contributed to shipping versions 1 and 2 of the CLI binary crate
• Introduced --pretty flag to the CLI to transform standard JSON or raw text outputs into human-readable ASCII tables
• Introduced a descriptor generator to the binary crate to help users create valid output descriptors without having to manually string together complex scripts.

Language Bindings for BDK (BDK-FFI)

Bitcoin Dev Kit BDK-FFI received several improvements from Itoro Ukpong, including:

• Enhanced the PSBT implementation to allow easier access to inputs and outputs. This improvement enables the sign method to return a mapping of input indices to the keys used for signing.
• Improved the user interface of the BDK-FFI Android sample app by enabling users to easily copy their generated Bitcoin addresses.
• Created a script that allows Windows users to build the BDK-FFI library locally on their windows machine.
• Added public_descriptor support to the wallet implementation.
• Added a wallet setup example for JVM binding.
• Tested new library releases and provided feedback, bug reports, and fixes for identified issues.

Bitcoinj library

Itoro Ukpong made several refactors and enhancements to the Bitcoinj library, including:

• Introduced a Kotlin module to the Bitcoinj project.
• Ensured version compatibility between the Kotlin and the versions supported by Bitcoinj.
• WalletTool: Created a design document outlining the structure and functionality of WalletTool subcommands.
• Contributed to the migration of WalletTool to a subcommand-based architecture.
• Removed deprecated Guava Joiner and Splitter utilities to modernize the codebase.
• Wallet refactoring: Contributed to ongoing wallet refactoring efforts, aimed at simplifying the core wallet class and aligning it with modern Java development practices.

Rust Bitcoin

Jamal Errakibi made several refactors and enhancements to the Rust Bitcoin library, including:

• Added a feature to align with Bitcoin Core policy by reducing the minimum non-witness transaction size from 82 to 65 bytes.
• Introduced a CoinbaseTransaction newtype to clearly distinguish coinbase transactions from other transaction types.
• Standardize BIP notation across the codebase to the BIP-XXXX format.
• Consensus Encoding improvements:
  • Added a new() constructor to CompactSizeDecoder.
  • Implemented CompactSizeEncoder and refactored WitnessEncoder.
• Added functional tests for assumeUTXO in Bitcoin core.

BTCPay Server

Tobechi contributed several integrations and plugins, including:

• Shopify Integration: Developed an open-source payment gateway enabling merchants to accept Bitcoin payments directly through their Shopify stores with zero fees. While the standalone Docker image has recorded over 1,000 direct downloads, the plugin is also used by hundreds of merchants running BTCPay Server on managed infrastructure platforms like Start9 and Voltage, indicating broader real-world adoption beyond direct downloads.
• Cal.com Payment Integration: Enabled Bitcoin and Lightning payments for appointments and bookings on Cal.com, an open-source scheduling platform. The implementation supports both Bitcoin and Lightning invoice payments
• Naira Checkout Integration with Mavapay: Created a plugin allowing Nigerian customers to pay in Naira while merchants receive Bitcoin. Recently expanded to include payout functionality supporting:
  • Nigerian Naira (any Nigerian bank)
  • Kenyan Shilling (bill payment, till number, account number)
  • South African Rand (South African banks)
• Satoshi Tickets Plugin: Built a plugin enabling event organizers, conference hosts, and community managers to sell tickets and accept Bitcoin payments via BTCPay Server. The plugin has so far been known to have been used in about 3 events and conferences, processing close to a thousand tickets, with millions of sats in transaction value.
• Payroll Plugin: Built a payroll plugin that enables businesses in Africa and globally to manage payroll and salary payments using Bitcoin via BTCPay Server. The plugin is currently used by multiple organizations, including BTC Inc, to execute recurring and bulk salary payments, moving significant volumes of bitcoin and supporting real-world, non-custodial payroll operations.

Looking Ahead: 2026 Priorities

In 2026, we intend to build on the momentum created by our developer grantees last year by:

1. Scaling the Btrust Builders program and grantee pipelines to onboard more contributors.
2. Strengthening Bitcoin Core’s contributor and review capacity by supporting and growing the pool of long-term open-source contributors.
3. Deepening technical contributions while ensuring high standards of code quality and mentorship.
4. Ensuring more cross-collaboration between Global Majority developer contributors.
5. Encouraging open-source project spearheading by Global Majority developer contributors.

At Btrust Builders, our work is grounded in the belief that Bitcoin’s open‑source ecosystem only thrives when contributors are supported not just to learn, but to stay, grow, and lead over time.

As interest in Bitcoin development continues to rise, we’ve learned that access alone is not enough. Developers need structure. They need clear expectations. They need guidance that meets them where they are, and a path that doesn’t disappear once a single program ends.

That’s exactly what the 2026 Btrust Builders Program is designed to deliver.

Many of the insights that shaped this year’s design are captured in the 2025 Btrust Builders Program Report. In 2026, we are building directly on that foundation with sharper clarity, stronger systems, and a deeper commitment to long-term contribution.

Our Vision for 2026

This year, Btrust Builders is being designed as a scaled, high-quality contributor pipeline. Our goal is to absorb large applicant volumes without sacrificing rigor or care. We aim to meet developers where they are through a mix of self-paced learning and guided support, while maintaining a clear bar for excellence. We are focused on producing developers who are genuinely ready to contribute to Bitcoin open‑source projects and, over time, become strong candidates for grants and long‑term ecosystem roles.

Equally important, we are committed to delivering a consistently excellent student experience across all cohorts while protecting the sustainability of our faculty and mentors through better tooling, clearer systems, and intentional cohort sizing.

What Success Looks Like in 2026

We are measuring success differently than before. Graduation matters, but so does retention. We care about how many developers continue after BOSS through structured pathways. We care about whether there is a clear progression from graduation to fellowship, and from fellowship to grants. We care about real open‑source output, including meaningful contributions and merged pull requests. We care about whether alumni are still contributing six to twelve months later. And we care deeply about faculty satisfaction and sustainability.

The Builders program in 2026 is not optimized for short‑term wins, but is designed for durable outcomes.

The Btrust Builders Architecture

The Btrust Builders program in 2026 operates as a connected, three‑layer system.

The first layer is the on-ramp: the Btrust Builders Pathways, focused on skill-building, strong foundations, and contribution readiness. The second layer is acceleration, which happens through the Open Source Fellowship; a selective, high-touch, contribution-driven experience. The third layer is outcomes, where contributors transition into grants, continued open‑source work, ecosystem placements, and an active alumni network.

Rather than treating these as separate programs, we’ve designed them as a single, continuous journey.

How the Builders Journey Works

Developers enter Builders either through open applications or via the BOSS challenge. BOSS is a high‑bar external one‑month challenge run by Chaincode Labs, and in 2026 and continues in 2026 to serve primarily as a filter and signal generator.

Once in the pathways, developers build the technical knowledge, tooling familiarity, and contribution readiness needed to engage meaningfully with Bitcoin open-source projects. Through consistent participation and performance, top contributors are identified and invited into the Open Source Fellowship. From there, developers who demonstrate sustained impact are well positioned for grants and long-term involvement in Bitcoin open-source work, ensuring continuity beyond short-term programs and strengthening the broader ecosystem. 

The Btrust Builders Pathways

The Btrust Builders pathways form the core learning engine of the program.

Each pathway is designed to help developers build confidence, skills, and contribution readiness at different stages of their journey. All pathways use a hybrid model that combines self-paced and shared learning with live, guided support. We work in small groups, assign chaperones, and set clear weekly expectations so developers always understand what success looks like.

Mastering Bitcoin

Mastering Bitcoin is an eight‑week beginner pathway focused on theory and conceptual understanding. It runs twice in 2026. Participants study Bitcoin fundamentals using Mastering Bitcoin: Programming the Open Blockchain, Third Edition by Andreas Antonopoulos.

Learning is structured around guided readings, discussion prompts, recorded walkthroughs, and weekly live Socratic discussions led by chaperones. Developers are also placed in small buddy groups to encourage consistency and collaboration.

The goal of this pathway is to build strong Bitcoin mental models and a solid conceptual foundation.

Learn Bitcoin from the Command Line

Learn Bitcoin from the Command Line is a seven‑week intermediate pathway that also runs twice in 2026. It focuses on practical interaction with Bitcoin Core through the command‑line interface.

Participants work through GitHub-hosted exercises, set up their development environments, and gain hands-on experience interacting with nodes, transactions, and the network. Learning is supported by structured materials, weekly live review sessions, and Socratic discussions. Where possible, submissions are automatically checked to reduce overhead and speed up feedback.

The goal is practical confidence with Bitcoin Core and contributor workflows.

Rust for Bitcoiners

Rust for Bitcoiners is a six‑week intermediate-to-advanced pathway running twice in 2026.. It is designed for developers preparing to contribute to Bitcoin open‑source projects written in Rust.

The pathway mirrors existing BTCdemy and Btrust Builders practical exercises, emphasizing consistency, code quality, and real contribution patterns. Developers work in small groups per chaperone, attend weekly office hours and mentor syncs, and complete a required capstone project.

The goal is Rust proficiency tailored specifically for Bitcoin open-source work.

Language Clubs

Language Clubs are six‑week intermediate-to-advanced pathways that also run twice in 2026. They focus on other key programming languages used in Bitcoin development, beginning with Python and C++.

Learning is structured and peer‑supported, using Exercism alongside Builders‑specific practical add‑ons. Developers work in small groups, receive mentor support, and complete a capstone project. Grading is lightweight, but consistency checks are strong.

The goal is fluency in Bitcoin-relevant programming languages.

The Resource Hub

In 2026, the Btrust Builders program will be supported by the Resource Hub.

The Hub is a continuously updated, always-on knowledge base that supports developers before, during, and after every program. It serves contributors at every stage of the Builders pipeline, reduces repeated questions, lowers onboarding friction, and reinforces open-source best practices and norms.

The Hub includes contribution cheat sheets, walkthroughs, and step-by-step guides for first pull requests, issue selection, reviews, and maintainer communication. It also features curated lists of Bitcoin open-source projects organized by language, stack, and contribution readiness, alongside environment setup guides, workflows, and both technical and non-technical articles.

Across the program, the Hub is referenced weekly in pathways, serves as the primary landing resource for BOSS developers, supports fellowship contribution workflows, and remains available to alumni as a long-term learning resource.

The Open Source Fellowship

The Open Source Fellowship is the centerpiece of Builders 2026.

It is a ten-week, selective program designed for top performers across all pathways. Fellows receive stipends, work with assigned mentors, and operate within small homegroups. They contribute to pre-approved open-source projects, participate in weekly standups and contribution reviews, and produce technical writing such as articles, walkthroughs, and documentation.

The fellowship culminates in a proof-of-work database that provides public visibility and serves as a clear signal to Btrust and partner funders.

By the end of the fellowship, developers are grant-ready, have a strong public contribution record, and are positioned for sustained open-source impact.

The 2026 Program Calendar

The 2026 calendar reflects the full Builders journey across the year.

• The year begins in Q1 with the BOSS challenge running from January 12 to February 12. From February 12 onward, BOSS candidates flow directly into Btrust Builders Pathways. The first cohorts of Mastering Bitcoin and Learn Bitcoin from the Command Line run from early March through late April.
• Q2 focuses on Rust for Bitcoiners and Language Clubs, running from May 11 to June 19.
• In Q3, the second cohorts of Mastering Bitcoin and Learn Bitcoin from the Command Line run from June through July. The Open Source Fellowship runs from August 3 to October 9.
• Q4 brings the second cohorts of Rust for Bitcoiners and Language Clubs from October 12 to November 20. The year closes with program review and planning in November, and the 2027 program plan launches in December.

This calendar is intentional. It creates multiple entry points, clear progression, and a steady rhythm of learning, contribution, and outcomes throughout the year.

Systems, Faculty, and Evaluation

The 2026 Btrust Builders Program is supported by improved systems and infrastructure. The LMS hosts all pathway materials, enables self-paced learning, and reduces administrative load through progress tracking, submissions, grading rubrics, and integrations with GitHub and Discord. The website and pathways pages clearly communicate the full pipeline, timelines, and outcomes.

Our faculty model includes a Head of Program, Head of Engineering, Faculty Members, Chaperones, and Fellowship Mentors, each with clearly defined responsibilities and time commitments. Evaluation across pathways uses a shared rubric focused on consistency, technical understanding, engagement, initiative, collaboration, and communication.

Alumni and Long‑Term Outcomes

Beyond learning and graduation, 2026 places explicit emphasis on long-term contribution and leadership.

By year-end, we will maintain a live internal database of Bitcoin open-source projects to improve contributor matching. We are launching an alumni contributor network with private channels and regular calls, building a curated alumni directory to support ecosystem visibility and opportunity matching, and documenting clear post-Builders pathways into mentorship, faculty roles, BitDevs leadership, and ecosystem coordination.

We are also introducing non-financial recognition systems and tracking alumni retention and impact at six- and twelve-month intervals.

Our goal is simple. Btrust Builders should not just train developers. We should retain contributors.

Join Us

If you’d like to learn more about the Btrust Builders program, explore the pathways, or apply, you can start here: https://btrust.homerun.co/btrust-builders-application/en 

If you’re not ready to apply yet, we encourage you to explore the Btrust Builders Resource Hub. It’s always available and designed to help you start learning, make your first contributions, and understand how Bitcoin open‑source development works.

About Us

Btrust Builders is Btrust’s comprehensive engineering program dedicated to training and funding African software developers to contribute to Bitcoin and Lightning open-source projects. The Builders program provides technical mentorship, community support, and structured pathways to sustainable Bitcoin development careers.

Written by Jamal Errakibi

This article is a written version of my talk “Why Rust Is Becoming Essential in Bitcoin,” which I gave during the 2025 Btrust Developer Day. 

If you prefer watching instead of reading, you can watch the talk linked here.

Rust has been voted the most loved programming language for nine years in a row, according to the 2025 Stack Overflow Developer Survey.

Yet ironically, it’s also considered one of the hardest languages to learn. Why? Because it introduces unique concepts like ownership and borrowing, ideas that don’t exist in most mainstream programming languages.

Today, many Bitcoin projects already use Rust: rust-bitcoin, BDK, rust-lightning, Fedimint, BitVM, Payjoin, Stratum V2, and more.

So the real question isn't, “Can Rust work for Bitcoin?”

It’s "Why are so many Bitcoin projects choosing Rust?"

The answer, in my opinion, comes down to what I like to call the three pillars of Rust.

The 3 Pillars of Rust

Rust is built around three strong ideas:

1. Memory safety without a garbage collector
2. High performance
3. A strong type system

Let’s explore why each of these makes Rust a natural fit for Bitcoin development.

1. Memory Safety (Without a Garbage Collector)

Memory safety means your program never manipulates memory incorrectly, a common source of bugs and vulnerabilities in software.

This is not a small issue. Industry leaders like Google, Microsoft, Mozilla, and Apple have all reported that around 70% of their security bugs are related to memory safety problems.

Even with thousands of engineers, most serious vulnerabilities still come from memory-unsafe code.

“~70% of the vulnerabilities Microsoft assigns a CVE each year continue to be memory safety issues.” — Microsoft Security Response Center

“If we’d had a time machine and could have written this component in Rust from the start, 51 (73.9%) of these bugs would not have been possible.” — Mozilla

Even the U.S. government released a report saying that future software should be memory safe. If you want to build critical infrastructure (or even get contracts with the White House), memory safety is no longer optional.

Common Memory Bugs (C/C++)

These are the classic memory bugs we see in languages like C and C++:

• Use-after-free
• Double free
• Data races
• Dangling references
• Buffer overflows

Rust gives us a way to avoid entire classes of these bugs before the code even runs. All of this happens at compile time.

Memory Safety in Bitcoin Core

This is not theoretical.

Bitcoin Core itself has had real bugs caused by memory unsafety:

• A use-after-free bug fixed in Bitcoin Core: https://github.com/bitcoin/bitcoin/pull/33956
• A double-free issue fixed in the wallet code: https://github.com/bitcoin/bitcoin/pull/14138

These are exactly the kinds of bugs Rust is designed to prevent.

How Rust Solves This

Rust avoids these problems through ownership and borrowing.

We won’t go deep into the details here, but the key idea is simple:

Rust makes entire classes of bugs impossible at compile time.

Not by tests. Not by runtime checks. But before the program even runs.

How Rust Does Memory Management

To really appreciate Rust’s approach to memory safety, it helps to understand how memory is managed in other languages.

Languages like Java, Go, and C# use a garbage collector to decide when memory should be freed. But a garbage collector is a full secondary process running in the background, and it comes with additional runtime cost and unpredictability.

C doesn’t have a garbage collector, but in return you have to manage memory manually. You allocate memory yourself, and you are responsible for freeing it correctly, which is exactly where most memory bugs come from.

Rust, on the other hand, does not have a garbage collector, and memory is managed by design using the ownership and borrowing model.

2. Performance

Rust is fast for three main reasons:

1. No garbage collector
2. Energy efficiency
3. Stack-first memory model

Let’s break this down.

No Garbage Collector

A garbage collector is a secondary process running in the background. It decides when to pause your program and clean up memory.

This makes performance unpredictable.

Discord Case Study (Go → Rust)

Discord migrated one of their services from Go to Rust.

https://discord.com/blog/why-discord-is-switching-from-go-to-rust

• The purple line represents the old Go service. You can clearly see periodic latency spikes, caused by GC pauses.
• The blue line is the Rust version. Much smoother, more predictable, and more deterministic.

Energy Efficiency

This study compares energy consumption across programming languages.

https://greenlab.di.uminho.pt/wp-content/uploads/2017/09/paperSLE.pdf

In the benchmark results, Rust is very close to C in terms of energy usage and significantly better than languages like Java or Python.

Less CPU time → less energy → lower costs. This matters a lot at scale.

Stack by Default

Rust is stack-heavy by default.

That means Rust tries to put data on the stack whenever possible, because it’s faster, safer, and doesn’t require allocation.

The heap is only used when we actually need dynamic or growable data structures.

This design choice alone removes a lot of overhead and complexity.

3. Type safety

“Safe Rust code is guaranteed to avoid undefined behavior. Type safety is a key element to reliability.” - Rustacean Principles   

Memory safety prevents how things go wrong at runtime. Type safety prevents what you are allowed to express in code.

Rust also helps you prevent bugs that have nothing to do with memory. It does this with a strong type system: you can make invalid states hard (or impossible) to represent.

What this means in practice:

- You avoid “null” problems by using Option<T> (a value is either Some(...) or None).

- You handle failures explicitly with Result<T, E> instead of hoping things “just work.”

- You can use enums to model protocol states and force exhaustive handling with match.

- You can create “newtypes” (small wrapper types) so you don’t mix up values that are both integers but mean different things.

Why these matter for Bitcoin codebases:

Bitcoin software is full of values that look similar but are not interchangeable: sats vs BTC, txid vs block hash, script types, network (mainnet/testnet), locktime/sequence rules, and more.

In weaker type systems, these often get represented as plain integers or strings, and mistakes compile fine.

In Rust, you can encode the meaning into the type and let the compiler catch mix-ups early.

Quick example:

Risks of Rust

Rust is not perfect.

1. Steep Learning Curve

Rust is hard at the beginning. The compiler feels strict. Sometimes too strict.

But that pain is usually teaching you something important.

2. The Compiler Can’t Catch Everything

Rust prevents memory bugs, but it can’t prevent logical mistakes.

A good example is the Cloudflare outage on November 18, 2025, which was caused by a misuse of unwrap().

In Rust, unwrap() basically means, “Give me the value or crash.”

Sometimes that’s exactly what you want. Sometimes it’s not.

Rust gives you powerful tools, but you still need to use them carefully.

Conclusion

Rust is like doing peer programming with the compiler.

It’s like having a super strict senior engineer sitting next to you all the time. You try something unsafe, and the compiler is like:

“Nope. Try again. Fix that first.”

It’s annoying, but it saves you.

Rust also Makes Things Simpler for Reviewers

Rust makes code reviews easier.

Because many classes of bugs are literally impossible, reviewers don’t waste time looking for:

• Use-after-free
• Data races
• Lifetime issues

The compiler already handled that.

So reviewers can focus on logic, not memory mistakes.

If you want to dive deeper into Rust and its use in Bitcoin, the following resources are highly recommended:

• Rust for Bitcoiners by Btrust Builders: https://btrust.homerun.co/btrust-builders-application/en
• Building Bitcoin in Rust by Lukáš Hozda:
https://braiins.com/books/building-bitcoin-in-rust
• The Bitcoiner’s Intro to Rust: https://btcdemy.thinkific.com/courses/intro-to-rust
• Rust for Rustaceans by Jon Gjengset:
https://rust-for-rustaceans.com

In 2025, hundreds of developers across Africa took their first steps into Bitcoin’s open‑source ecosystem, learning how it works, how to contribute to it, and how to build sustainable careers around it.

The Btrust Builders program was designed to move developers from curiosity, to capability, to contribution.

This blog shares the story of the 2025 program, what we achieved, what we learned, and why it matters for the future of Bitcoin development in Africa and the wider Global South.

Why Btrust Builders Exists

Bitcoin’s promise is global, but its development has historically been concentrated in a few regions. Btrust was founded to help change that reality by decentralizing Bitcoin open‑source development and supporting talent in the Global South.

The Builders program sits at the heart of this mission. It recognizes the truth that talent is everywhere, but access, structure, and sustained support are not.

Btrust Builders was created to close that gap by giving African developers the education, mentorship, and real‑world exposure needed to confidently engage with Bitcoin open source.

The 2025 Builders Program at a Glance

2025 was the Builders program’s most ambitious year to date.

Over the course of the year, 493 developers were supported across all pathways, from Africa and beyond.

The program received 1,800+ applications, a 180% increase over the previous year, reflecting growing demand for structured Bitcoin technical education.

Developers came from 15+ countries, spanning West Africa, East Africa, Southern and Central Africa, with additional participation from South America, Europe, and South Asia.

Unlike previous single-cohort models, Builders 2025 evolved into a continuous, modular learning pipeline. Developers could enter the program at any stage; whether they were exploring Bitcoin for the first time or ready to contribute to open-source projects.

A Modular Learning Model

One of the defining features of Builders 2025 was its multi‑pathway design. Instead of forcing developers through a linear track, the program offered multiple entry points based on skill level, experience, and goals.

This meant developers could start with foundational understanding, build hands‑on skills, and then move toward open‑source contributions when ready.

Across the year, Builders delivered:

• Foundational learning to anchor understanding
• Intermediate technical education for hands‑on skill‑building
• Advanced contribution environments to prepare developers for open‑source work
• Ongoing support through mentorship, peer discussions, and the Builders Resource Hub

This flexible design made the program accessible to a wide range of learners without compromising depth, rigor, or technical standards.

Learning Pathways

Mastering Bitcoin

For many developers, the journey began here. Using Mastering Bitcoin as a core text, this pathway helped participants build mental models of how Bitcoin actually works, from keys and transactions to mining, wallets, and consensus.

Through guided discussions and peer learning, participants gained confidence discussing Bitcoin at a technical level.

Of the 96 developers enrolled, 41 graduated, leaving with clarity and a solid conceptual foundation.

“I’d tried reading Mastering Bitcoin several times without success. This time, the group discussions made the concepts click,” one graduate shared.

Learn Bitcoin from the Command Line (Bitcoin CLI)

The next step for many was translating ideas into code. This pathway bridged theory and practice.

Developers worked directly with Bitcoin Core through the command line, learning how to run nodes, inspect transactions, construct raw transactions, and explore the network’s inner workings directly.

68 developers joined this pathway, with 24 graduating after seven weeks of structured exercises, peer sessions, and live group walkthroughs. Many demonstrated readiness to advance into open‑source‑focused pathways.

Rust for Bitcoiners

As interest in protocol‑level development grew, Rust for Bitcoiners became the most popular pathway.

Participants combined Rust programming with Bitcoin internals, learning how transactions are encoded, validated, and processed at the system level.

Closing with a capstone project where students built a command‑line tool that interacted with Bitcoin Core via RPC, this pathway gave learners both the skills and confidence to contribute to projects like rust‑bitcoin, BDK, LDK, and Fedimint.

Of 128 developers enrolled, 38 graduated, making this one of the most technically demanding and rewarding Builders experiences of 2025.

Language Clubs

For early‑career developers building foundational programming fluency, the Language Clubs were a low‑pressure but powerful starting point.

Using Exercism challenges and Builders‑designed Bitcoin examples, participants practiced Python or C++ in real Bitcoin contexts. This track emphasized fundamentals, problem‑solving, discipline, and code structure, while helping learners see how these languages power Bitcoin systems.

The cohort was small (20 developers) but represented one of the most inclusive spaces yet. About 25% of participants and half of the graduates were female.

Start Your Career in BOSS: Stepping into Open Source

The Start Your Career in BOSS pathway represented the most advanced track in 2025. Designed by Chaincode Labs, it exposed developers to the realities of open‑source contribution: ambiguity, independence, maintainer feedback, and long review cycles.

Interest was intense. 1,290 developers applied, with 181 admitted, and 21 advancing into deeper proof‑of‑concept work.

While no participants formally graduated under the program’s strict criteria, the pathway surfaced critical insights about readiness gaps and the need for stronger support structures.

In response, we launched a support plan: pairing developers with mentors, running weekly stand‑ups, peer reviews, and even well‑being check‑ins to maintain momentum.

This was a turning point. Engagement increased significantly, and several participants went on to attempt real contributions, submit pull requests, and continue contributing beyond the program.

The Open Source Bootcamp

If there was one standout success in 2025, it was the Open Source Bootcamp.

This four‑week sprint was designed to bridge the gap between training and contribution.

38 developers from 7 countries joined, guided by Builders faculty and mentors through weekly standups, contribution walkthroughs, and project reviews.

By the end:

• 103 code submissions were recorded
• 50+ pull requests were submitted across major Bitcoin projects
• 12 PRs were merged, including 3 to Bitcoin Core
• Contributions to projects like BDK, BlueWallet, BTCPay Server, Rust‑Payjoin, Polar, and others
• 15 developers were identified for the developer grant watchlist

For many participants, this was the first time contributing publicly to open‑source software.

“Seeing my PR merged for the first time,” one developer said, “was proof that my code could make a difference.”

The Resource Hub

One of 2025’s biggest successes was the Btrust Builders Resource Hub, which grew into a widely shared knowledge base across the global Bitcoin developer community.

What started as an internal library quickly became recognized by both faculty and non‑Btrust developers as one of the best‑curated Bitcoin education resources available today.

The Resource Hub became a map; a curated, open‑access collection of Bitcoin developer resources to help Builders (and anyone else) keep learning long after formal training ends.

The Resource Hub covers:

• Step‑by‑step notes and open-source cheat sheets for getting started: how to make your first pull request, find beginner‑friendly issues, and work effectively in public
• A list of open‑source Bitcoin projects, organized by language and tech stack
• Hands‑on materials and references for onboarding to developer environments
• Documentation and technical writing best practices
• Curated technical and non‑technical articles spanning every corner of Bitcoin learning

Everything on the Hub is open, living, and designed to inspire exploration rather than memorization. Developers are encouraged to verify, not trust, mirroring the ethos of Bitcoin itself.

By the end of 2025, it had become the go-to reference shared in workshops, meetups, and open‑source circles across the continent and beyond.

Looking ahead, the Hub will continue to grow in 2026, adding pathway‑specific resource maps, deeper technical walkthroughs, and more practical contribution guides for new developers joining the ecosystem.

Impact Beyond the Program

The impact of Builders 2025 goes beyond participation numbers or graduation rates. What mattered most was how developers progressed after the program, into contribution, recognition, and sustained involvement in the Bitcoin ecosystem.

Funded Open‑Source Contributors

In 2025, several Builders alumni transitioned into fully funded open‑source Bitcoin work, supported by Btrust and the Human Rights Foundation.

These developers are now contributing to core Bitcoin open-source projects:

• Rita contributing to the LDK Node, funded by Btrust. Btrust also published a grantee spotlight highlighting her journey into full‑time Bitcoin open‑source development.
• Ojok working on BlueWallet, funded by Btrust
• Abiodun contributing to Bitcoin Dev Kit, funded by Btrust
• Chuks contributing to the LDK Node, funded by Btrust
• Shammah working on Rust‑Payjoin, funded by Btrust
• Mohamed contributing to efforts advancing Bitcoin’s privacy and scalability, funded by Btrust
• Devgitotox contributing to Bitcoin Core, funded by the Human Rights Foundation

These outcomes reflect the core goal of Builders: supporting developers beyond learning and into long‑term, real‑world open‑source contributions.

Builders Alumni Starting Their Own Projects

Not all outcomes from Builders 2025 took the form of upstream contributions or grant‑funded work. For some participants, the program became the launchpad for starting their own Bitcoin projects.

Equipped with stronger technical foundations, open‑source workflows, and peer support, several alumni went on to build and experiment with new tools, applications, and infrastructure within the Bitcoin ecosystem. One of these projects is Bitika, which recently secured a Human Rights Foundation grant.

These efforts reflect another important dimension of the Builders pipeline: empowering developers not only to contribute to existing projects, but also to identify problems, explore solutions, and build new Bitcoin‑native products rooted in open‑source principles.

Contributors to Watch: Top Program Performers

Builders 2025 also placed strong emphasis on recognizing high‑performing participants and giving them visibility within the broader Bitcoin ecosystem.

The top five students from the 2025 program received full sponsorship to attend Btrust’s end‑of‑year events and the Africa Bitcoin Conference in Mauritius. They were also formally recognized and awarded at the 2025 Btrust Gala Dinner, celebrating their contributions and growth throughout the year.

These top students are: Ayokunle Akinsiku, Musa Haruna, Frank Chinedu, Busayo Dada and Yankho Ngolleka.

Their recognition reflects both technical progress and the consistency, discipline, and collaboration expected of open‑source contributors.

Faculty, Mentors, and a Contributor‑Led Model

Builders 2025 reinforced a hands‑on, contributor‑led learning model where participants learned directly from people actively building in the ecosystem.

Builders faculty and chaperones were not only instructors but also active open‑source contributors during the program. Notably, several of them also became grant recipients in 2025, receiving funding to become full-time Bitcoin open‑source contributors, demonstrating how the Builders pipeline effectively supports long‑term participation beyond the program itself.

Mentors, many of whom are themselves funded open‑source contributors, also played a critical role in guiding participants through technical challenges, contribution workflows, and the realities of working in public.

Recognition Across the African Bitcoin Ecosystem

The impact of Builders 2025 was also recognized beyond our community.

At the Africa Bitcoin Conference, the African Bitcoiners team named Btrust Builders the 2025 African Bitcoin Project of the Year. This recognition reflected the program’s growing influence across the continent and its role in strengthening Bitcoin education, open‑source contribution, and developer pipelines in Africa.

Skills That Outlast the Program

Beyond code contributions and funding outcomes, Builders participants developed the habits that define successful open‑source contributors: communication, constructive feedback, project discipline, and the resilience to stay engaged long after the coursework ends.

Why This Matters

The 2025 Builders Program proved that when developers are supported with the right mix of structure, community, and mentorship, they don’t just learn Bitcoin, they become part of its story.

Builders has matured from a series of workshops into a long‑term contributor pipeline. It’s now one of the key bridges connecting developer talent in the Global South to the global Bitcoin ecosystem.

Every new cohort adds to a growing network of people equipped to build and sustain Bitcoin’s open‑source foundations from every corner of the world.

Appreciation: The People Behind Builders

Programs like ours don’t succeed on structure alone. They succeed because of people.

Btrust Builders 2025 was made possible by the dedication of faculty and chaperones, many of whom are alumni themselves; mentors who gave their time, experience, and patience; and the core Builders team, including Stephanie, the program lead, and Kelvin, the engineering lead, who carried the vision from design through delivery.

Just as importantly, the wider Builders community, learners, alumni, contributors, and supporters, shaped the culture that made collaboration, accountability, and growth possible.

Together, they helped turn Builders into a shared effort to expand who gets to build Bitcoin.

What to Look Out for in 2026

The work doesn’t stop here. 2025 was about building structure and 2026 is about scaling.

After overwhelming requests from the community, we will be expanding the number of pathway cohorts this year, opening more on‑ramps for developers at all stages.

As Bitcoin grows, so must the diversity of the people building it. The Btrust Builders program is one way that future is being written: deliberately, collaboratively, and openly.

To learn more about our pathways and join the next cohort, explore the Resource Hub, or join our community, visit our website.

About Us

Btrust Builders is Btrust’s comprehensive engineering program dedicated to training and funding African software developers to contribute to Bitcoin and Lightning open-source projects. The Builders program provides technical mentorship, community support, and pathways to sustainable Bitcoin development careers.

For the past few years, developers and curious builders have been coming together to talk about Bitcoin; not the price, not speculation, but the technology itself.

These conversations have been technical, open, and deeply grounded in learning.

After helping to launch and support a growing number of BitDevs communities across the African continent, we are excited to share the first public release of a comprehensive guide for building and sustaining Bitcoin‑only technical communities.

The Playbook captures real experience from the ground and turns it into clear, practical guidance that others can use, adapt, and improve.

This matters now more than ever. As interest in Bitcoin development grows across the Global South, communities need structure, shared standards, and long‑term thinking to thrive. The BitDevs Playbook exists to meet that need.

Why BitDevs?

BitDevs began in New York City as a way for Bitcoin developers and researchers to regularly discuss recent technical developments, research papers, and open‑source work. Instead of talks or panels, the format emphasized discussion. Over time, this model proved powerful and spread organically to cities around the world.

What makes BitDevs special is not scale or branding, but how it strengthens local communities. Each location is independently run and shaped by its local context, but connected by shared principles. Meetups are Bitcoin‑only, technically focused, non‑commercial, and privacy‑respecting. The Socratic discussion format encourages participants to think critically, ask questions, and contribute meaningfully, regardless of seniority.

This model aligns naturally with Bitcoin’s own principles: decentralization, openness, and collaboration. By creating neutral spaces for technical discussion, BitDevs helps developers learn faster, contribute to open‑source projects with confidence, and connect their local work to the global Bitcoin ecosystem.

BitDevs Across Africa

Today, BitDevs communities are active across multiple regions of Africa, each rooted in its local context while contributing to a broader network of shared learning. Btrust supports 13 of 15 BitDevs locations across Africa, providing funding, structure, and logistical support that ensure consistency and sustainability across the network. A few others, backed by groups like Bitcoin Zambia and similar local entities, operate independently while contributing to the same shared mission.

Current and emerging BitDevs locations across Africa include Abuja, Lagos, Kaduna, Uyo, and Kano in Nigeria; Accra in Ghana; Cotonou in Benin; Douala in Cameroon; Gitega in Burundi; Goma in the Democratic Republic of Congo; Johannesburg in South Africa; Kampala in Uganda; Nairobi in Kenya; Mauritius; and Zambia.

Beyond their regular monthly meetups, these BitDevs communities have become important launchpads for developer growth. Members from these groups have gone on to participate in advanced programs such as Chaincode Labs’ BOSS program and the Btrust Builders pathways, deepening their technical skills and gaining real exposure to open‑source contribution. Some have taken the next step and started careers in Bitcoin open‑source development, supported through funding from Btrust and the Human Rights Foundation.

Others have gone on to build their own Bitcoin products and projects, translating community learning into real‑world impact. In several cities, BitDevs organizers and members have also partnered with groups like Africa Free Routing to host developer bootcamps, workshops, and hands‑on training sessions.

Through these efforts, BitDevs communities have provided value well beyond the meetup format, sharing opportunities, mentorship, and ongoing support that help members grow at different stages of their Bitcoin journey.

Why the BitDevs Playbook Matters

As BitDevs locations began to grow across the continent, a pattern emerged. Many organizers were facing the same challenges; figuring out how to start, how to stay consistent, how to work with sponsors responsibly, and how to maintain quality over time. Much of the knowledge needed to do this well existed, but it lived in private conversations or individual experience.

The BitDevs Playbook exists to make that knowledge shared. It provides clarity where there was uncertainty and structure where there was guesswork.

By documenting what works, and what doesn’t, the Playbook helps communities avoid common pitfalls and focus their energy on what matters most: learning, discussion, and building strong local networks.

What Is the BitDevs Playbook?

The BitDevs Playbook v0.1.0 is the first public release of a comprehensive guide for building and sustaining Bitcoin‑only technical communities. Developed and maintained by Btrust, it brings together years of hands‑on experience supporting BitDevs locations across Africa.

The Playbook is practical by design. It doesn’t assume ideal conditions or large budgets. Instead, it walks through real scenarios organizers face and offers clear, actionable guidance. It is meant to be used, adapted, and improved, not just read once and set aside.

What the Playbook Covers

The Playbook follows the full lifecycle of a BitDevs location. It begins with how to assess local interest, form a small organizing team, and host a first meetup. It then moves into the day‑to‑day realities of running a location, including planning monthly sessions, choosing technical topics, engaging participants, and keeping clear records.

It also sets out shared standards around quality, ethics, privacy, and neutrality, helping ensure that every BitDevs location maintains the trust of its community. Importantly, the Playbook addresses harder topics as well, such as managing challenges, avoiding organizer burnout, working transparently with sponsors, and responsibly pausing or closing a location when necessary.

Throughout the document, organizers will find templates, checklists, and examples that make the guidance easy to apply in real life.

Why This Matters for Africa and the Global South

Across Africa and the wider Global South, there is no shortage of talent or interest in Bitcoin. What is often missing are consistent, long‑term spaces dedicated to deep technical learning. Many developers learn alone or online, without peers to challenge ideas, share context, or grow together.

The BitDevs Playbook is designed to change that. It lowers the barrier to starting and sustaining local technical communities by providing clear guidance, shared standards, and proven processes. Instead of relying on trial and error, organizers can build with confidence from day one.

By empowering organizers and keeping communities independent and non‑commercial, the Playbook supports long‑term skill development, local leadership, and meaningful participation in Bitcoin’s open‑source ecosystem.

How to Start a BitDevs in Your City

Starting a BitDevs doesn’t require a large budget or a big team. The Playbook shows how to begin with local interest, a small group of committed organizers, and a clear focus on Bitcoin’s technical layer.

It walks through the essentials: choosing a venue, setting expectations, curating topics, running discussions using the Socratic format, and building consistency month after month. For communities seeking support, it also explains how sponsorship can work without compromising independence or community trust.

The goal is not rapid growth, but sustainable learning.

Open Source and Community‑Driven

The BitDevs Playbook is intentionally open. It is fully open‑source and licensed under Creative Commons Attribution 4.0 (CC BY 4.0). This means it can be freely shared, adapted, and improved with proper attribution.

The Playbook is a living document. As organizers experiment, face new challenges, and discover better ways of working, their insights can be contributed back. Over time, this shared learning will strengthen the entire network.

Who the Playbook is For

This Playbook is for anyone involved in the BitDevs ecosystem. It is for organizers starting a new location or strengthening an existing one. It is for organizing teams and volunteers who support logistics, moderation, and communication. It is for sponsors and partners who want to support grassroots technical communities without influencing content or direction. It is also for developers and participants who want to better understand how BitDevs meetups work and how to contribute meaningfully.

Acknowledgements

The BitDevs Playbook was developed and is maintained by Stephanie Titcombe, Program & Operations Lead at Btrust, with contributions and reviews from organizers and community leaders across the BitDevs network. Their shared experiences and feedback shaped this first public release and ensured it reflects the realities of building communities across diverse contexts in Africa.

Where to Find the Playbook

The BitDevs Playbook v0.1.0 is publicly available through the official GitHub repository. The repository includes the full Playbook, along with templates, annexes, and supporting materials that organizers can use directly. It also serves as the home for updates and future releases.

Call for Contributions

This release is just the start. Organizers, participants, and supporters are welcome to share feedback, suggest improvements, and contribute their own lessons learned. Please refer to the CONTRIBUTING.md file in the repository for detailed guidelines.

What’s Next

With the Playbook now public, the next phase is collective learning. As more communities adopt it and contribute back, future versions will continue to improve and reflect real‑world experience. The long‑term goal is to support a growing network of independent, technically grounded Bitcoin communities across the Global South; communities that learn together, build together, and contribute confidently to Bitcoin’s future.

About Us

Btrust is a non-profit organization with a dedicated mission to decentralize the development of Bitcoin Open-Source Software. Our focus is on fostering developer talent in the Global South and supporting the free and open-source Bitcoin ecosystem.

Global, December 31, 2025 - At Btrust, we know that growing the Bitcoin open-source developer ecosystem starts with creating gateways; spaces where curious builders can connect, learn, experiment, and ultimately take their first steps toward meaningful contribution.

These gateways often take the form of events: technical meetups, grassroots workshops, hackathons, and conferences that combine knowledge-sharing with real collaboration.

Through our event grants, we partner with initiatives that expand these entry points, laying the foundation for deeper engagement with Bitcoin developer education programs and helping to feed the open-source pipeline we’re building across Africa, Latin America, and the broader Global South.

In the second half of 2025, we supported nine unique events, each serving a distinct community, yet all contributing to a powerful network of collaboration, innovation, and opportunity for new Bitcoin contributors.

Dev/Hack/Day at BTC Prague

June 18 - Prague, Czech Republic

Ahead of BTC Prague, this one-day, in-person conference brought together Bitcoin devs, hackers, and tech enthusiasts for high-signal talks and networking. Inspired by its execution and energy, Btrust joined to learn from the model as we evolve our own Btrust Developer Day format. The program combined deep technical presentations with expert-led conversations, fostering connections across Europe’s Bitcoin builder community with the Global South.

OSCAFEST 2025

August 15 - 16 - Lagos, Nigeria

Africa’s largest open-source festival went beyond borders this year, uniting developers, students, designers, and organizations across industries. OSCAFEST’s mission of growing Africa’s open-source movement aligns squarely with Btrust’s goal of decentralizing Bitcoin development. With our sponsorship, we amplified Bitcoin’s presence in broader open-source conversations, inspiring cross-pollination between African FOSS communities and the global Bitcoin ecosystem.

Hack4Freedom

Late September to Early October - Kaduna & Online

Bitcoin, Lightning, Nostr, and eCash became tools for tangible change during Hack4Freedom, a two-week hackathon aimed at Nigerian women developers. Starting with an in-person kickoff, participants built open-source solutions to real local challenges, from censorship resistance to digital identity. Through mentorship, team collaboration, and a project showcase finale, Hack4Freedom empowered a new wave of female Bitcoin builders, making freedom tech personal and practical in the everyday lives of participants.

DevFest Mauritius 2025

October 4 - Moka, Mauritius

While not Bitcoin-exclusive, DevFest Mauritius served as a strategic outreach opportunity ahead of the 2025 Btrust Developer Day. With three parallel tracks centered on Google technologies, the event attracted a technical audience. Btrust’s participation ensured the conversation around open‑source Bitcoin development remained front and center, reaching new potential contributors within Mauritius’ growing developer community.

Code and Chain: A Bitcoin Meetup

October 18 - Lagos, Nigeria

Hosted by Bitnob, this developer‑focused meetup convened Bitcoin engineers, product builders, and open‑source contributors for demos, panel discussions, and networking.

The event spotlighted emerging local innovation and connected attendees directly to Btrust’s mission and resources. Code and Chain is designed to seed long‑term collaboration across Nigeria’s Bitcoin ecosystem, laying the groundwork for future hackathons, workshops, and co‑led programs.

Bitcoin CoreDev Meetup

October 2025

Organized by Brink, this focused gathering brought together Bitcoin Core contributors, Lightning implementers, and researchers to collaborate deeply on complex reviews and discussions.

We supported attendance for talented contributors, knowing that some breakthroughs happen only face‑to‑face.

Bitcoin Dev Summit & SatsConf at São Paulo Bitcoin Week

November 3, and 7-8 - São Paulo, Brazil

As part of the growing Latin American Bitcoin ecosystem, São Paulo Bitcoin Week brought together a full week of developer‑focused education, collaboration, and innovation.

Organized by Vinteum, the inaugural Bitcoin Dev Summit marked the first dedicated conference for Bitcoin developers in Latin America. With an audience of at least 80% software developers, the summit explored everything from consensus and validation to Lightning, Stratum V2, and developer tooling. Btrust’s support helped Vinteum expand its pipeline for open‑source onboarding, linking Latin American developers directly to global maintainers and leading projects.

Now in its third edition, Satsconf is the largest Bitcoin conference in South America and the centerpiece of São Paulo Bitcoin Week. While broad in audience, it remains deeply rooted in open‑source developer engagement, particularly through accompanying programs like SatsHack and Bitcoin Students Days.

Together, the Bitcoin Dev Summit and Satsconf underlined how regional collaboration and developer education can scale globally, strengthening the bridge between Latin America and the wider Bitcoin FOSS community.

DevFest Lagos 2025

November 18 - 22 - Lagos, Nigeria

DevFest Lagos, Africa’s largest community‑driven developer festival,  returned for its 12th edition, bringing together thousands of developers, designers, and entrepreneurs.

By reaching a wide and diverse developer audience, the event introduced new contributors to Bitcoin’s infrastructure and sparked meaningful, long‑term open‑source participation.

Why These Events Matter

These events range from highly technical, focused meetups to large‑scale multi‑topic conferences, across continents, skill levels, and formats. Yet each shares the same purpose: attract talent, spark curiosity, and connect communities to open‑source Bitcoin development.

In the Global South, the path to becoming a Bitcoin developer is more than technical training, it’s about access, community, and opportunity. Event grants ensure that these gateways stay open and inclusive, feeding into later-stage education programs, developer fellowships, and full-time open-source work.

We’ll keep identifying and supporting gatherings that set the stage for new contributors to thrive in Bitcoin’s open‑source future, in Africa, Latin America, and beyond.

Applications for Btrust Grants

Applications are open year-round for events that act as gateways into the Bitcoin open-source ecosystem. If your initiative inspires, educates, and connects potential Bitcoin contributors, we’d love to hear from you. Learn more about Btrust Event Grants and apply via our website.

Stay updated on our initiatives and future opportunities by following us on X, Nostr, LinkedIn, Instagram and Facebook.

About Us

Btrust is a non-profit organization with a dedicated mission to decentralize the development of Bitcoin Open-Source Software. Our focus is on fostering developer talent in the Global South and supporting the free and open-source Bitcoin ecosystem.

At Btrust, we’ve been fortunate to support developers whose work strengthens the foundations of Bitcoin. Today, we celebrate the journey of Duncan Dean, who joined us as a long-term grantee in April 2024 and whose time with us concluded in August 2025.

His contributions extended well beyond code. Over the past year and a half, he’s worked tirelessly on dual-funded channels in the Lightning Development Kit (LDK), collaborated with contributors across the ecosystem, and represented Btrust on global stages. Though this chapter closes, Duncan’s journey in Bitcoin open-source development continues, and we can’t wait to see where it leads.

A Legacy of Technical Contributions

Duncan first began contributing to LDK in 2021, and his time at Btrust accelerated some of the most significant progress to date.

• Dual-funding in LDK: He led the implementation enabling dual-funded channels, with PR 3137 and subsequent refinements such as PR 3423 and PR 3637. This work not only pushed dual-funding closer to completion but also laid much of the logical groundwork for splicing.
• Interactive Transaction Construction: Building on his early designs, Duncan contributed to the implementation of interactive transaction construction, a prerequisite for both dual-funding and splicing.
• Spec Contributions: His work surfaced new issues and improvements for the BOLTs specifications on dual-funding and splicing, contributing upstream fixes and refinements.
• Broader Open-Source Maintenance: Duncan played a key role in maintaining LNDK, improved its release process, and continued maintaining the Liana wallet package in NixOS/nixpkgs.

Duncan’s technical impact reached far beyond Btrust. His contributions were highlighted multiple times in the Bitcoin Optech newsletter, demonstrating his impact on the broader developer ecosystem.

Representing Btrust Around the World

His contributions extended well beyond code. As part of his grant, he represented Btrust and the open-source Bitcoin developer community at major events worldwide:

• Spoke at the inaugural edition of the Btrust Developer Day in Nairobi, Kenya
• Spoke at the 2025 edition of Adopting Bitcoin, Cape Town Conference
• Attended the Oslo Freedom Forum in Norway
• Spoke at the BTC Prague dev/hack/day
• Spoke at BTC Seoul in South Korea

At each of these gatherings, he not only shared updates on dual-funding and LDK but also advocated for the importance of open-source contributions and mentorship in Bitcoin.

Reflections on the Btrust Journey

When asked about his time with Btrust, Duncan shared: “Being a grantee at Btrust was, first and foremost, the best grantee experience I had throughout my grant-funded open source development career so far. One of the challenges in grant programs often shares a common thread of isolation and breakdown of communication between grantee and grantor. With Btrust’s evolution to a more structured approach, this common challenge was mitigated to a high degree.”

He also highlighted the sense of community, regular meetings, and reporting cadence as aspects that worked well, along with the support he received for conference applications, travel, and accommodations.

Looking back, he added: “The Btrust grant allowed me to continue working on LDK, which I initially started contributing to in 2021. The dual-funding project has made serious progress over my time at Btrust and has accelerated other contributors’ work on splicing. It’s been deeply rewarding to contribute to such an important piece of infrastructure, and I’ve really appreciated the freedom and support to work where I can be most helpful.”

What’s Next for Duncan

In September 2025, Duncan began a new chapter with Second building Bark, an open-source Ark implementation in Rust. He will continue contributing to LDK and the Lightning Network protocol through this work.

He also plans to:

• Grow BitDevs Johannesburg into a strong local hub, potentially feeding talent into the Btrust Builders program.
• Run Bitcoin-in-Rust workshops alongside the Socratic Seminars.
• Develop interactive Rust tutorials to onboard new contributors to projects like LDK and Bark.
• Provide mentorship to future Btrust grantees working on LDK and related projects.

As he puts it: “Contributions to Bitcoin, or other public goods, can often feel akin to offering your services of carpentry, masonry, or artistry to a cathedral of code and prose overshadowing everything else you do in life. We tell ourselves that the work is (mysterious and) important, and we are doing our part for the future of money. However, we must remember that Bitcoin is just a tool and not a religion. The only thing that would come of not looking after the most important parts of your life: contributors on the brink of burnout.”

Duncan has remained an active part of our community. He participated in our recently concluded gathering and spoke at the 2025 Btrust Developer Day, where he presented a session on how Ark and the Lightning Network can work together to unlock new possibilities for Bitcoin payments.

Thank You, Duncan

On behalf of everyone at Btrust, thank you, Duncan. Thank you for your dedication to advancing Bitcoin infrastructure, for representing Btrust on global stages, and for being an advocate for open-source development in Africa and beyond.

We’re proud to call Duncan a Btrust alumnus and friend, and we’re excited to follow his continued impact on Bitcoin open source.

All the best in your journey ahead.

Africa, December 12, 2025 — We’re excited to recognize six outstanding Bitcoin open-source developers awarded Btrust grants, including four starter grant recipients and two open-source cohort members.

Starter Grants

The Btrust Starter Grant provides support for software engineers ready to contribute full-time to open-source Bitcoin development. It allows recipients to explore areas of interest, identify a focus for long-term contributions, and engage deeply with the global Bitcoin developer community with relevant support via mentorship and without financial constraints.

Starter Grant Recipients

Shammah Destiny Agwor

Shammah is a software engineer based in Port Harcourt, Nigeria, with over eight years of experience spanning backend engineering, application security, and Bitcoin open-source development.

A graduate of the 2025 Btrust Builders pathways, he brings a deep understanding of secure system design and protocol-level engineering to his work.

Professionally, Shammah has served as an application security engineer at Swan Bitcoin and currently works in a similar capacity at Bitnob, focusing on secure development practices, vulnerability remediation, and production hardening.

Outside his professional roles, he has also been an active bug bounty researcher on HackerOne and Bugcrowd, earning recognition for impactful security findings.

In the open-source ecosystem, Shammah contributes to Rust-Payjoin, a privacy-enhancing Bitcoin project designed to improve transaction privacy by disrupting the common input ownership heuristic.

His merged contributions include introducing metrics collection to the Payjoin directory service and implementing caching optimizations for OHTTP keys to improve performance and reliability.

With the Btrust Starter Grant, Shammah will dedicate himself full-time to advancing the Rust-Payjoin project.

His focus areas include expanding observability through comprehensive metrics for Payjoin v2 adoption, refactoring the Payjoin directory service using the Axum web framework for improved maintainability, and enhancing performance and security through key rotation and middleware improvements.

Beyond code contributions, Shammah will also initiate a bi-weekly Payjoin PR Review Club to facilitate onboarding and peer review within the community. His work aligns directly with Btrust’s mission to strengthen Bitcoin’s open-source privacy stack and build long-term sustainable contributors across the Global South.

Mohamed Emad

Mohamed is a software engineer based in Suez, Egypt, and a computer engineering student at Zagazig University.

With a focus on systems programming and low-level software architecture, he has been actively contributing to Bitcoin privacy and performance projects through Rust-based development.

A graduate of the Btrust Builders pathways, Mohamed combines academic excellence with practical open-source experience, bringing a deep technical perspective to modern Bitcoin infrastructure.

His track record includes a standout contribution during Google Summer of Code at Metacall, where he built MetaSSR, a server-side rendering framework in Rust that achieved a 560% performance improvement over Next.js in HTTP benchmarks.

He also completed a successful project through Summer of Bitcoin, implementing the Mill-IO event-loop library for Citadel-Tech, a key step toward improving Bitcoin privacy protocols like Coinswap through efficient event-driven designs.

Through the Btrust Starter Grant, Mohamed will dedicate himself full-time to advancing Bitcoin’s privacy and scalability by enhancing the Mill-IO event-loop and leading a major migration of Coinswap to an event-driven architecture.

His work will introduce Bitcoin-specific optimizations, high-performance networking components, and a production-ready RPC framework designed to make privacy transactions faster and more resource-efficient.

Beyond performance improvements, Mohamed will publish detailed benchmarks, RFC proposals, and technical guides to assist other developers building high-performance Bitcoin applications.

His initiative directly supports Bitcoin’s long-term privacy infrastructure by reducing core bottlenecks and empowering new contributors with reliable tools for scalable development.

Simon

Simon is a software engineer based in Nairobi, Kenya, with over six years of experience in Bitcoin protocol development, C++ systems programming, and distributed mining infrastructure.

He has a degree in Computer Science, and has become deeply engaged in the technical and educational pillars of Bitcoin development across Africa. He is the co‑founder of BitDevs Nairobi, a Btrust Builders faculty member, and a committed Bitcoin educator who has facilitated developer bootcamps both within and outside Kenya, helping nurture the next generation of open‑source contributors.

Technically, Simon’s work lies at the intersection of Bitcoin Core internals and mining decentralization. He has made significant contributions to sv2‑tp (Stratum V2 Template Provider) and sv2‑apps, the reference implementation of Stratum V2.

His merged pull requests include support for multi‑coinbase outputs enabling merge‑mining, enhanced startup logging for better diagnosability, and critical bug fixes addressing undefined behavior in coinbase validation. Several of these efforts have directly informed ongoing discussions around Bitcoin Core’s mining interfaces.

With the Btrust Starter Grant, Simon will dedicate the next couple of months full‑time to making the Stratum V2 Template Provider production‑ready. His priorities include strengthening Bitcoin Core compatibility across versions 30 and above, raising test coverage to beyond 80 percent through exhaustive fuzzing, implementing advanced observability and security tooling, and supporting the first mining pools deploying the open Stratum V2 implementation.

Simon’s combined focus on technical rigor and community mentorship reflects Btrust’s mission to decentralize development and empower builders in the Global South. Through his work, thousands of miners will regain transaction‑selection power, advancing Bitcoin’s censorship resistance and reinforcing its decentralized future.

Ifeanyichukwu Amajuoyi

Ifeanyichukwu is a software engineer based in Lagos, Nigeria, with a background in mechanical engineering and over seven years of experience building scalable, high‑impact software systems.

A graduate of the 2024 Btrust Builders fellowship, he has since become a consistent open‑source contributor within the Lightning Development Kit (LDK) ecosystem, making meaningful contributions across rust‑lightning, ldk‑node, and ldk‑server.

His work spans code contributions, documentation improvements, issue triaging, and reviews, touching critical areas like payment routing, wallet operations, and protocol reliability.

Ifeanyi’s merged pull requests include improving fuzz corpus management for CI, fixing duplicate HTLC fail‑backs, and clarifying nuanced payment forwarding configurations.

His growing expertise in LDK architecture has also made him a frequent collaborator with project maintainers and an emerging mentor within the Builders community.

With the Btrust Starter Grant, Ifeanyichukwu will dedicate himself full‑time to advancing LDK Server, a foundational service for running large‑scale Lightning Service Providers (LSPs).

His primary objectives include implementing a unified logging system, developing a complete observability stack with telemetry and metrics, introducing PostgreSQL support for high‑availability deployments, and enhancing the BOLT 12 API feature set. These upgrades will help move LDK Server closer to production‑readiness and unlock adoption for advanced Lightning applications.

Beyond his technical focus, Ifeanyi remains active in the wider Bitcoin developer ecosystem, collaborating with maintainers, exchanging feedback in LDK PRs, and mentoring aspiring contributors through Btrust‑affiliated initiatives.

His planned work directly supports Btrust’s mission by strengthening open, reliable Lightning infrastructure and expanding the pool of experienced Bitcoin protocol engineers in the Global South.

Long Term Grants

The Btrust Open-Source Cohort offers long-term support to established Bitcoin open-source contributors, promoting a collaborative environment for sustained development.

Members receive funding paid monthly in Bitcoin, mentorship, and peer support to deepen their work on critical Bitcoin open-source projects.

The cohort model aims to build a resilient, inclusive developer ecosystem, enabling contributors from the Global South to make meaningful, lasting impacts on Bitcoin's open-source ecosystem.

Long Term Grant Recipients

Abdullahi Yunus

Abdullahi is a Bitcoin and Lightning Network developer from Nigeria whose work focuses on strengthening the reliability, interoperability, and feature completeness of Lightning implementations.

A graduate of the Btrust Builders program and a former Starter Grant recipient, he has become a key contributor to both Lightning Network Daemon (LND) and Lightning Polar, where his ongoing commits and in‑depth code reviews have significantly improved the ecosystem’s developer experience.

Over the past year under the Btrust Starter Grant, Abdullahi contributed critical improvements to the LND codebase, including features like channel‑backup archiving, CI stabilization, and advanced path‑finding enhancements, while also expanding Polar with SimLN and BTCD integration for better testing infrastructure. His active reviews across multiple repositories have helped maintain project stability and accelerate new feature readiness.

With this Btrust Long‑Term Grant, Abdullahi will deepen his work on the Onion Messaging (BOLT 4) implementation and downstream BOLT 12 Offers features in LND, key developments that enable private, invoice‑less payments and richer application‑level interactions over the Lightning Network.

His upcoming milestones include finalizing the forwarding infrastructure for onion messages, resolving long‑standing stability issues such as zombie‑channel pruning, introducing payment garbage‑collection mechanisms, and implementing pathfinding logic specific to onion‑message routes.

Beyond LND, Abdullahi will continue advancing Lightning Polar, adding a built‑in block‑explorer feature, integrating the latest node implementations, and ensuring interoperability in developer test networks. His planned collaboration with Lightning Labs engineers will help guide these features toward production‑quality releases.

Abdullahi’s long‑term focus on Onion Messaging, BOLT 12 Offers, and Polar tooling directly supports Btrust’s mission to foster open, decentralized, and privacy‑preserving Bitcoin infrastructure through sustained contributions from the Global South.

Sulaiman Aminu Barkindo

Sulaiman is a software engineer from Nigeria with over six years of professional experience and a dedicated contributor to Bitcoin open‑source infrastructure.

A former Btrust Starter Grant recipient, Sulaiman has become an integral part of the Validating Lightning Signer (VLS) project, contributing major advancements that have brought the software closer to mainnet‑readiness.

During his starter‑grant period, Sulaiman’s technical milestones included developing mainnet‑safe monitoring features through HTLC tracking, expanding disaster‑recovery capabilities to cover full‑channel and HTLC fund retrieval, and diagnosing a critical LDK integration bug that restored signing correctness during unilateral closes. His extensive code reviews and testing contributions have strengthened enforcement logic consistency throughout the VLS codebase.

With the Btrust Long‑Term Grant, Sulaiman will dedicate a full year to completing the final components required for VLS mainnet readiness and enterprise stability.

His focus includes strengthening signer state‑machine correctness, ensuring that channel state only advances after on‑chain confirmations, improving persistence atomicity across tracker and node systems, and extending fuzz‑testing coverage throughout signer operations. 

He will also enhance dependency security and auditability, upgrade KeysManager entropy handling, and implement key Lightning protocol extensions such as dual funding and splicing support.

Beyond protocol work, Sulaiman will contribute to enterprise‑scale validation, testing signer performance under production‑grade conditions and exploring secure enclave deployments for hardened environments.

His systematic approach, combining testing infrastructure, dependency governance, and performance optimization, ensures VLS’s evolution into a robust, auditable, production‑ready signer for Lightning applications.

Sulaiman’s continued leadership on VLS further anchors Btrust’s goal of advancing open‑source, non‑custodial Bitcoin infrastructure from the Global South, providing the security foundation needed for truly decentralized custody at enterprise scale.

Btrust Builders Alumni

Five out of six recipients of this quarter’s grants are graduates of the Btrust Builders program. The structured learning tracks they completed provided a strong foundation in Bitcoin fundamentals, hands‑on open‑source experience, and sustained mentorship from seasoned contributors.

Their progression from Builders graduates to funded grantees reflects the program’s mission to cultivate high‑potential developers across the Global South and prepare them for long‑term, sustainable careers in Bitcoin open source. Each grantee’s journey underscores what focused guidance, community collaboration, and opportunity can achieve when paired with dedication and talent.

Btrust Builders is partnering with Chaincode Labs for the 2026 ₿OSS (Bitcoin Open‑Source Software) Challenge, a structured, hands‑on program designed to help developers take their first steps into Bitcoin open‑source contribution under the guidance of experienced mentors. Learn more about the partnership and program here.

Interested in following a similar path as our Q4 recipients? Apply to join the 2026 ₿OSS Challenge cohort and become part of the next generation of Bitcoin open‑source developers. Applications are ongoing and will close on the 31st of this month.

Explore other Btrust Builders pathways here.

Applications for Btrust Developer Grants

Btrust developer grant applications are open year-round, with new recipients announced quarterly. If you’re a developer passionate about contributing to Bitcoin open-source development, we encourage you to apply.

Learn more about our grant programs and apply through our website.

Stay updated on our initiatives and future opportunities by following us on X, Nostr, Instagram and LinkedIn.

About Us

Btrust is a non-profit organization with a dedicated mission to decentralize the development of Bitcoin Open-Source Software. Our focus is on fostering developer talent in the Global South and supporting the free and open-source Bitcoin ecosystem.

Following a landmark 2025 cohort that saw several alumni become grantees supported by Btrust, the collaboration between Btrust Builders and Chaincode Labs continues for another year.

Together, we’re inviting talented African developers, new and experienced alike, to take part in one of the most impactful programs for Bitcoin open-source contribution.

Applications are open until December 31, 2025. Don’t miss your chance to join the next generation of ₿OSS contributors.

What Is the ₿OSS Challenge?

The ₿OSS Challenge, created by Chaincode Labs, is a structured, hands-on program designed for developers serious about beginning a career in Bitcoin open-source software.

The challenge starts with one fully guided month of coding exercises and learning, offering participants clear direction and support from active Bitcoin contributors.

After completing this first month:

• Top performers are invited to continue for two additional months of advanced mentorship with Chaincode Labs, working on proof-of-concept projects and collaborating directly with established Bitcoin and Lightning projects.
• The rest of the cohort transitions into partner-supported activities, like the Btrust Builders pathways, where participants continue building their skills, contributing to exercises, and engaging with the broader open-source community.

This refined structure provides every participant, whether new or experienced, with approachable guidance at the start, followed by personalized tracks for ongoing growth.

The program is fully remote, free, and designed to help developers become confident, independent ₿OSS contributors.

A Proven Path to Funded Bitcoin Development

The 2025 ₿OSS Challenge proved how transformative this opportunity can be. Several Btrust Builder participants from the program have since become Btrust-funded grantees, continuing their journey as full-time open-source contributors after just a few months of focused work and mentorship.

The ₿OSS Challenge is intentionally rigorous. It’s meant to spark lasting growth and connect motivated developers to a global network of contributors and maintainers. Those who show initiative and technical skill can open doors to sustainable, funded careers in Bitcoin development.

A Shared Mission: Decentralizing Bitcoin Development

Btrust Builders and Chaincode Labs share a common mission; to decentralize Bitcoin development by empowering a new generation of engineers.

By creating pathways into ₿OSS, the partnership expands the cultural and geographical diversity of Bitcoin contributors, ensuring that the network’s technological and social resilience continues to grow.

“Our alumni from the 2025 ₿OSS Challenge have proven what’s possible when access meets ambition,” said Stephanie, Btrust Builders Program Lead. “We’re proud to see them become funded contributors, and we’re excited to bring that same opportunity to even more developers in 2026.”

What to Expect

Participants can look forward to a balance of self-guided learning, active mentorship, and collaborative engagement within the ₿OSS network.

The ₿OSS Challenge offers:

• Hands-on Bitcoin & Lightning development focused on real-world open-source contribution.
• Technical mentorship from Bitcoin Core and ecosystem developers.
• Collaborative development challenges that strengthen your coding fundamentals in Rust, C/C++, or Python.
• A learning structure that encourages self-motivation, curiosity, and resilience, qualities essential for any open-source contributor.

Participants should plan to dedicate at least 10 hours per week, and all challenges are conducted in English.

Why Apply

Joining the ₿OSS Challenge through Btrust Builders gives developers from across Africa:

• Access to world-class open-source mentorship.
• A pathway into funded Bitcoin development through Btrust and community grants.
• The chance to contribute to Bitcoin Core, Lightning, BDK, and related open-source projects.
• A vibrant community of peers dedicated to learning, building, and growing together.
• And as always, participation is completely free.

Key Dates

Applications Close: December 31, 2025

Program Start: Week of January 12, 2026

Applicants who pass the preliminary challenge will be admitted to the cohort and begin their journey toward becoming part of the ₿OSS contributor ecosystem.

Apply Now

If you’re a developer ready to take your first real step into Bitcoin open-source development, apply to the 2026 ₿OSS Challenge. Learn more about the program and apply here.

About the Partners

Btrust Builders

Btrust Builders is Btrust’s comprehensive engineering program dedicated to training and funding African software developers to contribute to Bitcoin and Lightning open-source projects. The Builders program provides technical mentorship, community support, and pathways to sustainable Bitcoin development careers.

Chaincode Labs

Chaincode Labs is a Bitcoin research and development center, based in New York, dedicated to advancing the Bitcoin protocol and supporting the broader open‑source ecosystem. The organization’s mission is to strengthen the Bitcoin network through research, education, and long‑term support for open‑source development.

Written by Rita Anene

For over three years, I've worked as a software developer, building features and solving problems in the familiar rhythm of a 9-to-5 job. But something was missing. I wanted to work on technology that wasn't just functional, but foundational, something that could reshape how people interact with money and trust itself.

That's what led me to Bitcoin.

Discovering Bitcoin's True Potential

I first heard about bitcoin in 2018, but back then, I only understood it as "internet money". Over the years, I picked up bits and pieces, but my understanding remained surface-level. Then, in 2024, everything changed when I discovered an entire development ecosystem of developers working on Bitcoin protocols and projects that utilize Bitcoin's full potential.

This is when I found Btrust, a Bitcoin-focused organization dedicated to education and empowering new builders. Learning about their work sparked something in me. I realized that decentralization wasn't just a buzzword; it was a paradigm shift I wanted to be part of.

The BOSS Program

Btrust Builders, in partnership with Chaincode Labs, ran the 2025 Bitcoin Open Source Software (₿OSS) Starter Program, an intensive, three-month cohort designed to onboard developers into Bitcoin's open-source world. The program description was both exciting and intimidating.

During registration, I received my first taste of what was to come, which included instructions to read the first three chapters of Mastering Bitcoin and to learn Rust through a Building Bitcoin in Rust course. I completed the entrance challenge, and by the first week of January 2025, I was accepted into the program.

The program officially kicked off in January 2025 with Week 0, an RPC Scavenger Hunt using Bitcoin Core and Bash scripting, along with reading the first three chapters of Mastering Bitcoin. This wasn't going to be easy. I was juggling this intensive program with my full-time job, so I became what I later called a "vampire coder", working after hours, late into the night, and throughout weekends.

I read those chapters during my commute, treated weekends as deep-dive sessions, and found myself genuinely excited about this completely different world from my daily office tasks.

The Structure

The BOSS program was designed across three months, which was focused on code-heavy Bitcoin and Lightning fundamentals.

Each week brought new challenges alongside new chapters of Mastering Bitcoin. Week 4 was my turning point—the Lightning Network. I'll never forget that moment when Lightning clicked for me. I didn't fully understand it initially, but something about its elegance (instant payments, smart routing, off-chain scalability) captured my imagination completely. The Lightning challenges became the ones I solved fastest, not because I was an expert, but because I was genuinely excited.

First Real Contribution: Warnet and Circuit Breaker

Month 2 arrived with its challenge: build a Proof of Concept. From the available projects, I chose to integrate Circuit Breaker (a monitoring tool for Lightning nodes) into Warnet (a Bitcoin/Lightning network simulator).

This was my first time contributing to a Bitcoin project. Honestly, my hands were shaking as I forked the repositories. The task required me to learn YAML, Kubernetes, and Warnet's plugin architecture, all while maintaining my day job.

I submitted my first PR suggesting one approach, but the maintainer guided me toward a better solution: implementing Circuit Breaker as a Kubernetes pod rather than a plugin. Through this process, I learned about pods, container orchestration, and how Warnet actually works. After reviews and revisions, my PR was eventually merged. Now, anyone can run Warnet and choose to add Circuit Breaker as a pod running alongside the LND (Lightning Network Daemon) pod.

Finding LDK Node

While working on Warnet, I had already set my sights on my next challenge. Since I'd fallen in love with Lightning, I wanted to contribute to a Lightning-focused project. Two projects from a site Btrust shared caught my attention: BDK (Bitcoin Development Kit) and LDK Node (Lightning Development Kit Node), both Rust-based. My heart was set on LDK Node, a Lightning implementation in Rust.

Here's where things got real. Open-source can be intimidating, especially when you're new. The issues felt impossibly complex. The codebase was dense, and I was still learning Rust. I started second-guessing myself, wondering if I should switch to a project with more beginner-friendly issues.

Community and Mentorship

Btrust Builders had assigned me a mentor, Theophilus, who, along with Tobechi, a Btrust grantee working on BTCPay Server, gave me advice that changed everything:

"Don't jump ship. Pick any issue, research it thoroughly, and start working on it. Read the codebase over and over again. Go through PRs (both merged and open) and you'll gain understanding."

When two experienced Bitcoin developers are saying the same thing, you listen.

Around the same time, I was connected with Eni, a contributor to LDK Node, who welcomed me and confirmed that it was a fascinating project to work on. Her encouragement meant the world to me.

I also started attending the BitDevs Lagos meetups in January 2025. My first BitDevs was eye-opening, meeting like-minded people, learning from their experiences, and realizing I wasn't alone in this journey. By June, I was confident enough to host a session myself.

Breaking Through: My First PRs on LDK Node

Following the advice received, I stayed with LDK Node. I picked an issue, researched it, understood the problem, and crafted a solution. My first PR was a learning experience. It got reviewed, changes were requested (expected for someone new to the project), but eventually, it was merged.

That first merged PR was a breakthrough moment. Suddenly, the codebase started making more sense. I went on to create a second PR, each one teaching me more about LDK Node internals.

Let me tell you about trying to get the project running locally, that was an adventure in itself. I went through hoops trying to figure out the testing setup, but eventually found a workflow that let me test my changes before submitting PRs. (I now know a better approach and plan to write about it soon.)

The Btrust Starter Grant

All of this (the PRs, the code reviews, the late-night debugging sessions) was happening while I maintained my full-time job. I was essentially only able to attend to reviews, create PRs, or research issues after work hours, at night, or during weekends.

Then came life-changing news: I was accepted for the Btrust Starter Grant for Q3 2025.

This wasn't just funding, it was the opportunity to contribute to Bitcoin open source full-time. No more waiting after work hours or until midnight to open my IDE. For the first time, I could work on Bitcoin development during the day, not just as a nighttime vampire.

Since receiving the grant, I've been able to dive deeper into research, create two more PRs on LDK Node, and significantly deepen my understanding of LDK Node. I've learned that this ecosystem isn't just about coding, you need a deep understanding of what you're building and how it works.

My journey involves continuous research into not just Bitcoin, but Lightning Network protocols, strengthened by ongoing study of Mastering Lightning Network and improving my Rust skills.

What I Learned

The BOSS program taught me that Bitcoin development is collaborative. I learned enormously from peers at different experience levels. Some knew more about Lightning and Bitcoin than I did, while I was able to contribute knowledge in areas where I had more experience. This diversity of backgrounds and expertise made the learning environment rich.

One thing became clear: you don't need to be an expert to start contributing. What matters is curiosity, persistence, and willingness to learn. Some problems require looking at them more than once or twice before understanding clicks. The key is not giving up when things seem complex.

What's Next

My journey is far from over. Over the next few months, I plan to gain deeper knowledge of LDK Node and Lightning Network's protocol design, strengthen my Rust proficiency, and gain an understanding of Bitcoin's layered architecture. Most importantly, I want to guide others as I've been guided, especially in Africa, where Bitcoin's potential for financial sovereignty is real.

Working on Bitcoin isn't just about the technology, it's about building infrastructure for a more open, decentralized financial system. Every PR, every code review, every late-night debugging session contributes to something larger.

Gratitude

I'm grateful to Btrust, Chaincode Labs, my mentors Theophilus, Tobechi, and Eni, my BOSS cohort peers, Tnull, the maintainer on LDK Node for being welcoming and his guidance during PR reviews, and the wider Bitcoin open-source community. You didn't just teach me how to code, you showed me how to build with purpose and conviction.

To anyone starting out: it's okay to feel lost initially. It's normal to not understand Lightning or Bitcoin's complexities on the first try. What matters is showing up consistently, asking questions, and trusting that the community (when you engage with humility and genuine curiosity) will support your growth.

The path from curious developer to Bitcoin contributor isn't always smooth, but it's rewarding. And now, for the first time in my journey, I get to walk this path in the full light of day, contributing to the future of money and freedom.

The vampire coding days are behind me. The real building begins now.

Leadership transitions mark important moments in any organization’s journey, and today, we’re excited to share one of our own.

In July, we put out a call for a Chief Executive Officer. After receiving multiple strong applications and going through a long, thoughtful, and rigorous selection process, we’re happy to announce that Abubakar Nur Khalil has been appointed as the new CEO of Btrust.

Abubakar will be stepping down from his position on the Board to take on this full-time role, where he will report directly to the Btrust Board. His appointment marks a meaningful next chapter for Btrust as we continue our mission to strengthen and support open-source development across Africa and beyond.

About Abubakar Nur Khalil

Abubakar Nur Khalil is a Nigerian Bitcoin Core contributor and a leading voice in advancing open-source Bitcoin development across the Global South.

He served as Interim CEO of Btrust for over a year, beginning in August 2024, while continuing to contribute as a non-voting board member.

Abubakar brings a wealth of experience through his work co-founding Btrust Builders, alongside his many contributions across the African and global Bitcoin ecosystems.

As a respected Bitcoin Core contributor, he embodies the technical excellence, community leadership, and commitment to decentralization that define Btrust.

His background adds credibility and sharp focus to our work, helping us stay true to Bitcoin’s core values and our mission of inclusion and open-source growth.

A Transformative Year of Growth

From August 2024, Btrust underwent one of its most transformative periods yet; a year defined by clarity, structure, and principled execution.

During this time, Abubakar led Btrust through a period of deep growth and change, grounded in a strong commitment to our mission.

Under his leadership, Btrust transitioned from early groundwork into executing at scale, expanding programs across Africa, Latin America, and India; launching new partnerships; significantly growing developer reach; improving how we review and deliver grants; and refining our internal systems and team structure.

We expanded flagship programs, redesigned learning pathways, graduated and onboarded hundreds of developers, and grew our reach to over 3,400 contributors across Africa, Latin America, and India.

Through partnerships with organizations such as Bitshala, Librería de Satoshi, Vinteum and 2140, Btrust extended its collaboration across multiple continents and strengthened the global Bitcoin development ecosystem.

Our grant programs also saw record-breaking growth, surpassing $1.7 million in funding since mid‑2024 to date, with more than half of all support going directly to developers, while our educational and community initiatives expanded into new regions and technologies.

This past year has shown what’s possible with steady, principled leadership. Btrust is stronger, more focused, and better positioned to deliver on its mission.

Above all, Abubakar leads with intention and respect. He is thoughtful in his decisions, transparent in his approach, and empowering in how he works with the team. He invites ownership, values collaboration, and creates space for each person to contribute meaningfully to high-impact work.

“I’m honored to have led Btrust as interim CEO over the past year, building a great team and creating standardized structures for our operations, grants, and collaborations. I look forward to even greater impact in 2026 and beyond, establishing Btrust as the leading Bitcoin grant organization empowering open-source Bitcoin developers from the Global Majority and ensuring that Bitcoin continues to be a money that works for everyone worldwide,“ said Abubakar Nur Khalil.

A New Chapter for Btrust

Abubakar’s transition from interim to full-time CEO signals continuity, and evolution. His leadership and technical vision will guide Btrust into its next phase: scaling our operations sustainably while deepening global partnerships and continuing to empower developers across the Global South.

Over his three-year term, renewable once by a subsequent board, Abubakar will steer Btrust toward building sustainable systems that empower communities and developers everywhere.

“It was through my role on the Btrust board that I first had the opportunity to meet and work with Abubakar, and in that time I’ve come to know him as a smart, articulate, structured leader who is consistently calm under pressure. This is a uniquely challenging role with much to learn, but I believe Abubakar — supported by strong mentors, the board, and an exceptional team — has the capability to continue developing, learning, and advancing Btrust’s mission in the years ahead. I wish him the best of luck in his stewardship of Btrust’s vision and values.” added Obi Nwosu.

We’re confident that under his leadership, Btrust will continue to grow, forge stronger partnerships, and strengthen the decentralized foundations that define our work.

Looking Ahead

We’re grateful to everyone who applied, participated, and supported this process. Each application reflected the collective drive to ensure Bitcoin’s future remains open, inclusive, and community-led.

Join us in congratulating Abubakar Nur Khalil on his new role, and stay tuned as we begin this exciting next phase together.

In the world of Bitcoin development, talent is everywhere. Yet, for many developers in the Global South, especially across Africa, reaching the highest levels of contribution isn’t just about skill or dedication—it’s about access.

Opportunities to meet global collaborators, speak at conferences, and work alongside seasoned peers are often stalled at the border. Visa challenges mean promising voices go unheard on international stages, and career-defining connections go unmade.

At Btrust, we believe these barriers should never define a developer’s trajectory. That’s why we launched the Btrust Pull Partnership, an initiative designed to bridge worlds: supporting our grantees not only with funding, but with the global exposure, mentorship, and logistical help they need to thrive.

How the Pull Partnership Came to Life

The idea took shape after our successful collaboration with Chaincode Labs last year, where our grantee, Abubakar Sadiq Ismail, worked with leading Bitcoin developers at their New York offices, gained hands-on experience, and successfully navigated the visa process.

Over the years, Btrust’s grant framework has evolved to help developers in the Global South move from promising local talent to globally recognized contributors.

Phase one of this process focused on identifying and funding developers to help them find their footing in open‑source Bitcoin projects. Phase two built on this by sharpening technical skills and leadership through targeted grants and structured mentorship. Now, phase three aims to break down geographical and logistical barriers, enabling African developers to collaborate with global teams, attend key conferences, and bring back critical knowledge to strengthen local ecosystems.

As Btrust CEO, Abubakar Nur Khalil, notes, “Bitcoin as a money provides the ability for developers to receive equal compensation for their valuable work regardless of geographical location. With Pull Partnerships, we aim to enhance this freedom by providing equal growth opportunities for developers, allowing them to thrive without being hindered by visa-related restrictions.”

The Pull Partnership is a flagship example of phase three in action. By pairing Btrust‑funded developers with partners like 2140 in Amsterdam, we not only give them access to world‑class mentorship, but also actively support visa processes, relocation logistics, and integration into global bitcoin communities. This ensures African developers can take the stage internationally while building hubs of excellence back home, inviting future talent to learn, grow, and contribute to Bitcoin’s open‑source future.

It is important to note that the term “Pull” in the partnership, akin to pull requests in open-source development, is intended to emphasize that partner organizations must agree and be willing to collaborate, as Btrust does not foist this participation on them.

Taking the Idea for a Spin

The Pull Partnership model was first piloted with 2140 in Amsterdam earlier this year, building on lessons from our previous collaboration with Chaincode Labs in New York. While Chaincode proved the concept, the 2140 pilot became the blueprint for a structured, formal program backed by clear metrics, milestones, and defined responsibilities.

In this partnership, following the agreement of the partner organization, Btrust places its grantees directly into the partner organization’s professional environment, ensuring they receive meaningful mentorship, access to global networks, and opportunities to contribute to key open‑source Bitcoin projects.

Btrust provides support to cover salaries, employer taxes, and relocation logistics, and helps the visa applications process from official documentation to regular communication to ensure alignment with the goals of the Btrust Open‑Source Cohort (BOSC).

Meanwhile, 2140 employs and hosts the developers in their Amsterdam office, offering technical guidance, career development support, and access to important Bitcoin industry events. Progress is jointly tracked through regular reporting and agreed upon evaluation points, ensuring the placement delivers tangible impact, both for the developers and for the wider Bitcoin ecosystem.

Mutual Benefits

For Btrust, the Pull Partnership removes structural barriers that have long kept African developers from gaining the international exposure needed to thrive. It also ensures those developers bring back skills, networks, and perspectives that strengthen local communities.

For the partner organization, it means working alongside highly skilled and motivated contributors who bring fresh perspectives and enrich projects, while building meaningful ties to a growing developer community in the Global South.

Looking Ahead

The Pull Partnership is just the beginning. One that fits squarely into Btrust’s long‑term vision to establish strong bases in African and Global South cities, where developers from all over the world can come, learn, and grow. In the future, this exchange will be two‑way: collaborations will happen not only abroad, but equally on African—and similar—soil.

“We hope to make Pull Partnerships more than just a Btrust thing, by standardizing it for other Bitcoin grant organizations to get involved." Abubakar Nur Khalil, Btrust CEO added.

With more partnerships planned in the coming years, we view the Pull Partnership as a vital step toward making Bitcoin development truly global, without limits.

Africa, October 14, 2025 — We’re excited to recognize six outstanding Bitcoin open-source developers awarded Btrust grants, including four starter grant recipients and two open-source cohort members.

The four starter grant recipients are all graduates of the 2025 Btrust Builders pathways. The program offers structured tracks that cover everything from Bitcoin fundamentals to advanced hands-on open-source contributions, preparing participants for long-term careers in Bitcoin development.

In addition, one engineer has progressed from a starter grant into the long-term open-source cohort, and another has received a renewal of his long-term grant, enabling both to continue and expand their contributions to Bitcoin open-source projects.

Starter Grants

The Btrust Starter Grant provides funding for software engineers ready to contribute full-time to open-source Bitcoin development. It allows recipients to explore areas of interest, identify a focus for long-term contributions, and engage deeply with the global Bitcoin developer community with relevant support via mentorship and without financial constraints.

Starter Grant Recipients

Rita Anene

Rita is a software developer based in Nigeria, and an alumna of the 2025 BOSS cohort. With three years of experience and a background in building financial and logistics applications, she redirected her focus to Bitcoin in 2025. Her contributions span projects like Warnet, a Bitcoin Testnet simulation tool, and LDK Node, a Lightning Network implementation.

With support from the starter grant, Rita will dedicate herself to strengthening transaction lifecycle management, payment tracking, and storage optimization in LDK Node, while also enhancing Warnet with dynamic plugin configuration.

Her planned work directly tackles long-standing issues such as resolving stuck RBF (Replace-By-Fee) transactions, enabling clearer Invoice/Offer states, and improving user fee control. Rita is also an active voice in the Lagos BitDevs community, co-hosting events and mentoring newcomers.

Ojok Emmanuel Nsubuga

Ojok is a software engineer based in Uganda. Professionally, he has led engineering at Ridelink, while advancing his Bitcoin journey through the Btrust Builders open-source bootcamp and command line pathway.

He has contributed extensively to BlueWallet, fixing long-standing bugs, refactoring the codebase, enabling fee customization, and mentoring new contributors through reviews.

Through the starter grant, Ojok will focus full-time on modernizing BlueWallet; migrating the project from JavaScript to TypeScript, strengthening reproducible builds for F-Droid distribution, and reducing dependency vulnerabilities. He will also enhance BlueWallet’s Silent Payments library, aligning it with Bitcoin Improvement Proposals (BIPs) and preparing it for wider adoption by the ecosystem. His contributions will strengthen both Bitcoin privacy and the quality of a widely used self-custodial wallet.

Abiodun Awoyemi

Based in Lagos, Nigeria, Abiodun is a versatile software engineer with deep expertise in Rust, TypeScript, Solidity, and zero-knowledge proofs. A graduate of the Btrust Builders pathways, his open-source contributions already span the BitcoinDevKit and Rust Bitcoin ecosystems. His prior work includes implementing anti-fee-sniping mechanisms, introducing robust locktime validation types, and hardening GitHub Actions security workflows.

With the starter grant, Abiodun will drive six critical improvements across Bitcoin Dev Kit, including flexible RBF transaction construction, enhanced cross-wallet interoperability, caching improvements, streamlined public key derivation APIs, and more secure signing workflows. Alongside technical contributions, he will also produce tutorials, blog posts, and video materials bridging complex Bitcoin concepts for new developers.

Chukwudi “Chuks” Agbakuru

Chuks is a Nigerian software engineer with over eight years of experience, ranging from enterprise integrations to independent development. A consistent contributor to LDK, LDK-Node, and SimLN, he has authored features, conducted non-trivial reviews, and played a pivotal role in advancing testing frameworks. Outside open-source, he is also building PeepsWire, a video-calling application powered by Lightning micro-payments.

Through the starter grant, Chuks will dedicate himself to finalizing BIP 353 (Human-Readable Names) support in LDK Node, bringing a major usability improvement to Lightning infrastructure. He will also extend SimLN with support for LDK Node and develop new advanced simulation features. His active presence at BitDevs Lagos and commitment to mentoring new contributors underscore his role in strengthening the wider Bitcoin developer ecosystem.

Long Term Grants

The Btrust Open-Source Cohort offers long-term support to established Bitcoin open-source contributors, promoting a collaborative environment for sustained development. Members receive funding paid monthly in Bitcoin, mentorship, and peer support to deepen their work on critical Bitcoin open-source projects.

The cohort model aims to build a resilient, inclusive developer ecosystem, enabling contributors from the Global South to make meaningful, lasting impacts on Bitcoin's open-source ecosystem.

Long Term Grant Recipients

Itoro Ukpong

With seven years of professional software development experience, Itoro has become deeply engaged in the Bitcoin ecosystem over the past year. During his starter grant, he contributed significantly to BDK-FFI with 16 merged PRs, 30 PR reviews, and improvements to the devkit wallet sample app. His consistent contributions led to him being recognized as a maintainer and granted merge access on BDK-FFI, as well as secondary maintainer status on bdk-jvm.

With this long term grant, Itoro will continue to lead and enhance the API surface of the BDK-FFI layer as part of the major migration to version 3.0. His focus includes deepening the Partially Signed Bitcoin Transactions (PSBT) functionality, building a robust testing suite with regtest integrations, advancing Miniscript descriptor support, and maintaining developer-facing libraries and sample wallets like devkit wallet (Android) and Godzilla (desktop). He also plans to author the Android section of the Book of BDK, sharing best practices for secure and performant Bitcoin wallet development.

Itoro’s sustained leadership across BDK-FFI and bdk-jvm ensures developers worldwide gain reliable, cross-platform libraries for building Bitcoin applications, advancing both ecosystem usability and adoption.

Oghenovo “Novo” Usiwoma

Novo is a full-time Bitcoin Core open-source developer dedicated to advancing privacy and performance. His contributions include implementing Silent Payments, optimizing batch verification of Schnorr signatures, and enhancing libmultiprocess within Bitcoin Core.

A talented engineer based in Nigeria and a graduate of the 2023 Btrust Builders cohort, Novo has been actively contributing to Bitcoin Core and other Bitcoin projects since completing the program. His recent work under the first year of the Btrust Open-Source Cohort focused on deepening Bitcoin Core’s Silent Payments functionality.

With this long-term grant renewal, Novo will continue driving key privacy-preserving features and performance improvements at the protocol level, strengthening Bitcoin’s usability, security, and resilience for users worldwide.

Btrust Builders Alumni

This batch is especially meaningful as all six grant recipients are alumni of the Btrust Builders program. The structured learning tracks they completed offered a foundation in Bitcoin fundamentals, practical experience, and mentorship while contributing to open-source projects.

Their progression from Builders graduates to funded grantees highlights the program’s mission to cultivate high-potential developers in the Global South and prepare them for long-term, sustainable careers in Bitcoin open source.

Interested in following a similar path as our Q3 recipients? Apply to join the waitlist for upcoming Btrust Builders cohorts and be part of the next generation of Bitcoin open-source developers.

Applications for Btrust Developer Grants

Btrust developer grant applications are open year-round, with new recipients announced quarterly. If you’re a developer passionate about contributing to Bitcoin open-source development, we encourage you to apply.

Learn more about our grant programs and apply through our website.

Stay updated on our initiatives and future opportunities by following us on X, Nostr, and LinkedIn.

About Us

Btrust is a non-profit organization with a dedicated mission to decentralize the development of Bitcoin Open-Source Software. Our focus is on fostering developer talent in the Global South and supporting the free and open-source Bitcoin ecosystem.