How will appchains bring centralized product experiences to users?
TechFlow Selected TechFlow Selected
How will appchains bring centralized product experiences to users?
The most important question is not which design is best suited for decentralized platforms, but which design gives decentralized platforms the best chance to compete with centralized platforms.
Navigating Web3 tides with focused insights
Author: Natalie Mullins
Translated by TechFlow
The design space of blockchains has recently opened up. We no longer only have monolithic blockchains, but also:
-
Modular blockchains;
-
Data availability and consensus layers;
-
Rollups and execution environments;
-
Application-specific chains, and more.
While there are many options available for developers, the most important question is not which design is best suited for decentralized platforms, but rather which design gives decentralized platforms the best chance to compete with centralized ones.
Because blockchain use cases differ, it's impossible to find a one-size-fits-all answer. Therefore, this article focuses on appchains—one of the most viable yet underexplored approaches to addressing this challenge. We'll dive into how appchains can facilitate the creation of truly innovative products and features, as well as explore the sovereignty benefits they offer to projects.
Advantages of Appchains
When considering the various architectures mentioned above, it’s not immediately clear which solutions best address user experience pain points while maintaining sufficient decentralization.
Each approach involves trade-offs, but appchains offer an extremely important and unique advantage: sovereignty.
From a technical standpoint, sovereignty can be seen as vertical integration.
This means application developers can control and customize every layer of the blockchain stack to meet their application’s specific needs.
In addition to reducing reliance on middleware solutions, it eliminates competition with other applications for blockspace and reduces dependency on other projects’ development roadmaps and governance.
These advantages are particularly attractive to projects that have reached a certain scale and require greater throughput, frequent upgrades, and/or wish to control the future direction of their platform.
Technical sovereignty also allows app developers to unleash their creativity by experimenting with different consensus models, custom node requirements, state models, and other exciting features. Just as many new L1s have emerged specifically targeting core architecture innovations that couldn't be achieved on existing chains, appchains bring the same level of optimization to individual applications.
On a social level, social sovereignty fundamentally refers to an individual application’s ability to prioritize its values and manage trade-offs that matter most to it.
It enables communities to control their own destiny, including taking actions such as hard forking the blockchain for political or technical reasons. While most projects willing to build an appchain do so primarily for technical reasons, the need for social sovereignty should not be underestimated. Now and in the future, some applications will choose social sovereignty and join appchains simply because they feel other ecosystems don’t sufficiently align with their values.
Trade-offs and Concerns
Appchains aren’t a perfect solution for all projects—they merely represent a particular viewpoint on what trade-offs blockchains and applications should make.
Many critics cite composability and liquidity fragmentation as key reasons why appchains are unsuitable for DeFi.
However, these concerns are less compelling when we consider that liquidity on general-purpose L1s is also concentrated among a few popular applications.
Instead of forcing users to switch between DEX chains, lending chains, perpetual chains, liquid staking chains, etc., integrating all these functionalities into the core products of several highly liquid DeFi appchains can significantly reduce liquidity fragmentation.
It's also worth noting that while Ethereum remains the center of gravity for DeFi, its rollup-centric scaling roadmap brings its own implications for composability and liquidity fragmentation.
Although appchains are not exclusive to the Cosmos ecosystem, due to its mature developer tools and heterogeneous composability (features still absent in ecosystems like Ethereum), many appchains choose Cosmos as their base.
Compelling Features and Experiments
The best way to fully grasp the power of appchains is to explore some of the most compelling user experiences being built today—particularly on Osmosis, Mars Protocol, Penumbra, and dYdX.
Osmosis
Osmosis is an appchain-based DEX and emerging liquidity hub within the Cosmos ecosystem. Osmosis was initially inspired by a blog post by co-founder Sunny Aggarwal titled “DAOifying Uniswap Automated Market Maker Pools,” aiming to bring Cosmos-style customizability and sovereignty to the world of AMMs.
Today, the protocol allows users to create liquidity pools with unique and modifiable parameters, enabling experimentation with different types of bonding curves, multi-weighted asset pools, and more. A hybrid liquidity model combining order book matching with centralized liquidity pools is also under active development.
As a pioneer in the DeFi appchain space, Osmosis has brought numerous innovative features to market, including superfluid staking—an elegant solution for users torn between staking rewards and DeFi yields.
Users can stake any LP token containing $OSMO—contributing to chain security while returning additional value to the community. This feature is possible because the Osmosis chain can recognize application assets and utilize them in PoS consensus, and there’s no reason this capability can’t be extended to other similar use cases as more features and asset types go live.
When it comes to creating CEX-like user experiences, Osmosis is working to integrate margin trading and lending directly into its core product. The team is currently collaborating with Mars Protocol to embed lending directly into the Osmosis trading engine, enabling staged liquidations, cross-margining across assets, and using Osmosis LP tokens as collateral for margin trading. As Osmosis contributor Steview Woofwoof succinctly outlined in a Medium article earlier this year:
"Staged liquidations ensure that unexpected volatility doesn’t lead to catastrophic liquidation of leveraged positions. Efficient cross-margining means Osmosis (unlike stateless DEXs) can track all your collateral from different assets and pools block-by-block, allowing it to function as a single large collateral pool backing all your loans and margin positions."
"Another benefit of building a lending protocol inside a DEX is eliminating the need for external oracles. In fact, Osmosis price data itself may serve as input for oracles used by other platforms. Of course, using external oracles as backup or to enhance security against certain attacks (e.g., price manipulation, dDOS) remains useful."
Osmosis is also exploring several creative approaches to handling MEV on its DEX—approaches that are notably easier to implement on an appchain, including:
-
Threshold encryption—encrypting user transactions before broadcasting to block producers, decrypting and executing only after blocks are voted on and finalized.
-
Fee discrimination—charging different fees for different transaction types (e.g., making arbitrage trades more expensive).
-
Skip—building Flashbots-like functionality directly into the base protocol.
-
Internalized MEV—building protocol-level arbitrageurs and distributing revenue to $OSMO stakers.
Mars Protocol
Mars is a cross-chain credit protocol being developed by Delphi Labs and a pioneer of a new type of DeFi known as contract-to-contract (C2C) lending. Initially deployed on Terra, the Mars team later reevaluated their product strategy and decided where to invest in the future. After surveying the entire landscape of L1s and L2s, the Mars team ultimately chose a unique Outpost & Hub model, allowing them to enjoy the benefits of both existing L1s and appchain sovereignty.
Red Bank is an instance of Outposts—a non-custodial, overcollateralized lending protocol deployable across various chains—enabling atomic composability with other apps on the same L1. It also serves as the liquidity source for C2C lending, as authorized smart contracts can borrow from Red Bank without posting collateral. The current plan is to launch the first Outpost on Osmosis.
The Mars Hub is an appchain with two key functions:
-
Managing all Outposts (including voting on which contracts are approved for C2C lending)
-
Collecting revenue from all Outposts and distributing it to $MARS stakers and validators
So far, most DeFi protocols' cross-chain strategies involve redeploying on all popular L1s or building bridges to connect appchains. This Hub & Outpost model attempts to achieve the best of both worlds by integrating with existing high-liquidity DeFi ecosystems while simplifying governance and token value accrual—all while mitigating fragmentation issues on mainnets.
The Delphi Labs team places strong emphasis on delivering the best possible user experience for DeFi. Once launched, Mars will be one of the most competitive attempts yet at replicating centralized exchange UX. The development roadmap includes many other exciting new features, such as the Rover credit account, which will allow users to leverage a single account for trading across various DeFi products.
Penumbra
Penumbra is a cross-chain shielded asset pool and appchain DEX that leverages privacy to improve on-chain trading and market-making experiences. The project originated from frustration over low adoption and interest in privacy-preserving tools like Zcash, combined with a desire to build a product that becomes better precisely because it’s private. However, as recent years have shown, privacy turns out to be a much harder problem than many initially imagined.
Despite ample funding, many attempts have been made to build privacy computing on blockchains. Yet the Penumbra team was unsatisfied with any existing approach. Instead, they posed a subtler but crucial question: If public shared state is what makes blockchains useful, how can we build a private ledger that’s equally useful?
For Penumbra, the concept of public shared state is central to blockchain utility—precisely because it means anyone wanting to use the blockchain only needs to coordinate with the chain itself, not off-chain counterparties.
Therefore, they argue that although previous attempts to design privacy-preserving L1s and rollups may solve privacy, they do so in ways that severely limit meaningful interaction with public shared state.
Ideally, private computation would protect individual privacy while keeping important aggregate data transparent. However, building a system capable of managing these trade-offs requires a state model fundamentally different from anything currently on the market—so the Penumbra team is building from scratch.
Moreover, while currently focused exclusively on trading and market-making use cases, the research and design work underway could have broader implications for privacy and scalability in other contexts.
Privacy on blockchains is achieved by moving user data and execution off-chain: replacing on-chain user data with encrypted commitments, and replacing plaintext execution with zero-knowledge proofs of correct state transitions—requiring a different state model.
Unlike state models centered around globally mutable state—where valid transactions alter state during execution—Penumbra adopts the concept of immutable, composable state fragments, where each transaction consumes input state fragments and produces output ones (conceptually similar to Bitcoin’s UTXO model).
This allows state fragments to be replaced with commitments to those fragments, and transaction contents replaced with proofs of valid state transitions.
However, the problem with this approach is that since execution moves off-chain, shared state is no longer accessible—because the exact final output of proposed state transitions must be included as transaction inputs before submission.
For example, DEX trades require freezing the exact state of AMM reserves and the precise output price before submitting a transaction on-chain.
Unique State Model
Penumbra’s state model is designed first and foremost to enable private interactions with public shared state, achieved through an actor model that explicitly separates off-chain computation (private, handling individual user states) from on-chain computation (public, handling shared state).
In the actor model, users create messages (rather than transactions), encrypt them, and send them to smart contracts. Each smart contract then executes once per block, taking as input all messages sent to it during that block—enabling batch processing of transactions or applying any custom application logic. This also provides scalability benefits, as each contract executes only once, spreading computational costs across all transactions in the block. Validators then decrypt some summary information about the batch before asynchronously executing transactions and producing public outputs.
This asynchronicity is enabled via private NFTs that record intermediate execution states and simulate future states. Once the contract responds with output messages, the private NFT is consumed to prove the correct future state was modeled, and the contract’s message is used to generate private execution outputs. The trade-off here is that execution may span multiple blocks.
Private Staking
To protect delegator privacy and validator accountability, the Penumbra team had to take a novel approach to staking design. Instead of treating “unbonded” and “bonded” as different states of the same equity token, bonded stakes are recorded as delegation tokens. These tokens represent percentage shares in a validator’s delegation pool, much like LP tokens represent shares in a liquidity pool.
While the size of each validator’s delegation pool is part of the public chain state, delegation tokens retain privacy by being traded among users and stored in a multi-asset shielded pool (where all value on Penumbra is recorded). Finally, staking rewards are calculated by tracking the exchange rate between staking and delegation tokens—a design with favorable tax efficiency, as only unbonding events are taxable.
Ultimately, Penumbra bets that privacy is actually a core component of the trading experience—and more importantly, that their customizations will lead to better execution. Enabling privacy-preserving strategies brings more sophisticated and capital-rich participants into the ecosystem, resulting in better liquidity, pricing, and reduced slippage. Their vision is to create a user experience that offers more privacy than CeFi, while retaining DeFi’s openness and permissionless advantages.
dYdX
After becoming the largest application deployed on Ethereum L2s, perpetual exchange dYdX recently announced plans to build V4 as an appchain. In the official announcement, the “unique combination of decentralization, scalability, and customizability” was cited as the primary reason—but it’s worth digging deeper into each of these factors:
Decentralization
Facing regulatory resistance, especially in the United States, many DeFi projects are encountering serious legal challenges. dYdX V3 is currently deployed on an Ethereum L2 (StarkEx). Although solutions are actively being researched and developed, these DeFi projects may not be able to wait for the full realization of decentralized rollups. dYdX was one such project that ultimately decided operating its own chain with approximately 100 validators was its best available option.
Scalability
Given that dYdX V3 currently processes about 10 transactions per second and around 1,000 orders/cancellations per second, the team surveyed the entire blockchain landscape for a chain capable of increasing throughput by several orders of magnitude—but found none. So they adopted a more creative solution: a decentralized off-chain order matching network. The dYdX chain only needs to reach consensus on settled trades, not on every order placed—enabling V4 to unlock truly exceptional scalability.
Technically, this design is feasible because appchains allow customized nodes—for example, requiring validators to help operate oracle networks or cross-chain bridge infrastructure.
Customizability
In an interview with Bankless, dYdX founder Antonio Juliano shared his ambitious vision for a fully vertically integrated product and user experience—including building not just a base L1, but also custom execution modules, off-chain order networks, oracle networks, mobile apps, and custom wallets. Juliano described this effort as “very risky,” but was also very clear that he believes it’s the best path to delivering the highest-quality user experience for dYdX.
Conclusion
For all the advantages and innovative experiments highlighted above, we must acknowledge that building an application-specific blockchain is technically far more challenging than deploying an app as a smart contract—or even deploying it within a dedicated execution environment (rollup, subnet, etc.).
This real-world challenge should not be underestimated. Yet neither should the potential benefits of the vastly expanded design space offered by appchains. Superior user experience is not only how decentralized products can defeat their centralized competitors—it’s also a critical component of building moats in an open-source, permissionless world.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
