
Picture two apps going live on the same day. One is a game where players dodge, jump and trade items in real time. The other is a treasury app where a community votes on how to spend its funds a few times a month.
Block time is the one critical function every app inherits from its shared network and apps on shared networks can’t change it. On a shared chain, such as a smart contract platform, it is set once for everybody, and for a long time that was a reasonable way to run things. Every block arrives at the interval the network chose, and every action waits for the next one. For the game, that interval decides how responsive an action feels. For the treasury app, it barely matters. Neither app developer picked the number; it came with their network.
App-specific block time fixes that, and it’s the focus of our latest work on the Canopy client. Each app on Canopy should be able to run at the pace its users need. For apps that need to move faster, we’re testing a new opt-in consensus mode that produces consistent 500ms blocks in a local test. The code is open for review.
A network’s block time is a compromise. Validators need enough time to receive a proposed block, check it and vote on it before the next one arrives. A network with many validators spread across the world has to leave room for the slowest message on the slowest connection, so it settles on an interval that keeps everyone in sync. For the network as a whole, that’s a sensible choice.
A smart contract developer can make their code faster and cheaper to run, but they can’t change how often the network produces a block. A trading app that wants to update orders several times a second gets the same cadence as a governance app that updates once a week.
For most apps, that’s a quiet tax, and it limits what gets built. Developers work around it with offchain order books, optimistic interfaces and batching. Those can be good engineering, but they move important logic off the chain, and the chain is the part users are supposed to be able to trust.
Canopy starts from a different place. Each app runs its own state machine and its own instance of consensus, with its own set of validators, using the Canopy Stack. Since apps don’t share consensus, there’s no technical reason one app’s block time has to match anyone else’s.
The work underway makes that independence practical. Each app configures its own block timing, separate from Canopy’s own cadence. A game can run fast, and a governance app can run slowly and cheaply. Neither choice affects the other, and Canopy’s network doesn’t have to speed up or slow down to suit either one.
For a builder, the starting point becomes the pace the app actually needs, and whether its validators can sustain it.
Every block starts with a proposer, the validator whose turn it is to assemble the next block and send it to the others. Canopy’s default consensus, NestBFT, picks the proposer using a verifiable random function, or VRF. The randomness is deliberate. If nobody can predict the next proposer far in advance, nobody can easily target that validator to stall the network.
Redwood’s Fast BFT gives up some of that unpredictability for speed. Proposers take turns in a predictable rotation weighted by stake, so every validator can work out who comes next from the state they already agree on. The implementation also lets a voting round move forward as soon as the votes it needs have arrived which allows validators to move onto the next phase immediately. When everything is healthy, validators spend less time waiting between blocks.
Timers still matter when a proposal goes missing or a validator stops responding, and the change includes improvements to how a round recovers when that happens.
We ran Redwood’s Fast BFT on four validators in Docker on a single machine, and it held consistent 500ms blocks. When we restarted one of the validators, it caught back up with the others cleanly. The side-by-side recording of a Redwood localnet next to a default localnet shows the block counters running under those conditions.
So the new path can hold its target pace and recover from a common failure, at least in that setup. The test doesn’t tell us how the mode behaves with a larger validator set, with operators spread across continents, or with an app under sustained heavy load. We still need to test those conditions.
Block time is also only one part of how fast an app feels. A transaction still has to reach the network and be processed, and an app that depends on an outside service has to wait for that service too. Two blocks a second doesn’t mean every action completes in half a second, but it does mean less of each action is spent waiting on the chain.
The predictable proposer schedule that makes Redwood’s Fast BFT fast is also its main tradeoff. If anyone can see which validator proposes next, so can an attacker, and it becomes easier to aim a disruption at that validator at the right moment. Some apps and validator setups can accept that risk in exchange for speed. Others can’t.
There’s a practical limit as well. Validators still need enough time to exchange messages, run the app’s logic and verify each block. Set the interval below what those conditions allow, and rounds start failing without the app getting any faster.
The existing VRF-based path stays the default, and Redwood’s Fast BFT has to be chosen deliberately. That keeps the decision with the people who understand the app and its operating environment, and one app’s need for speed never changes the security assumptions of another.
A lot of onchain activity today is a person sending a transaction and waiting for it to confirm. The apps we’re most interested in involve software working with other software, where a single request can set off several actions between participants before anyone sees a result. The waits between those actions add up, and more so when each one is paced by a network-wide clock set for someone else’s workload.
Giving each app control over its own pace, plus a faster option when it has a reason to use one, is groundwork for those apps. We’ll have more to share soon on what we’re building on top of it. The implementation is still under review. You can follow the code and the discussion in PR #648, and read more about how NestBFT and apps work in the Canopy docs.

Let your ideas take root and thrive. Deploy in minutes, with instant protection, distribution, and ownership.