For Developers

N1 is designed to be the most powerful playground for developers, and enable the next generation of crypto applications.

Unblocking key app development bottlenecks

• (today) compute is shared -> creating noisy-neighbor problem
  • N1 solves shared compute by allowing each app to run in its own dedicated environment, allowing it to scale vertically without any congestion and state contention
• (today) compute is limited -> limiting the complexity of what can be built
  • N1 enables virtually unlimited horizontal scale by adding on additional nodes per app
• (today) expressivity and iteration speed is limited -> to build onchain developers need to learn Solidity and blockchain specific concepts, they can’t easily customize execution environment, and widely used languages like Typescript can’t be used in the context of app development (limiting the number of possible developers)
  • N1 has an execution environment agnostic architecture, allowing developers to use languages like Typescript to build apps

Re-imagining the next generation blockchain

We’ve designed N1 the way we think Ethereum should have been designed since the start if it wanted to become the rails for application development

• L1 with decoupled settlement and execution layers
  • Settlement layer:
    • Unlike other blockchains, does not execute programs, making it very thin, lightweight, and efficient
    • Primarily provides security to applications that run on the execution layer, through data availability, and proof verification
    • Leverages consensus-less quorum to achieve security, which is both secure and more efficient than depending on consensus for everything. Uses consensus only for operations that require consensus.
  • Execution layer:
    • Unlike other blockchains, the execution layer allows each app to run in its own dedicated environment, allowing it to both scale vertically, and inherit full customizability of its stack (from enabling different programming languages, to defining the way it interacts with other apps in the network)
    • This allows each app to scale vertically, and reach 100k+ tps on its own (this is in stark contrast to other chains where the advertised TPS is the maximum TPS of all apps)
    • There is no state contention nor locking, and apps interact with each other through message channels–this is similar to how apps and servers interact on the internet
    • This also allows each app to use their preferred environment (EVM, wasm (TS, Rust), etc.) – this will significantly speed up development onboarding, especially for new developers unfamiliar with Solidity
    • TLDR: global composability is preserved, while enabling vertical scaling and customization per application
• Why do you need your own settlement layer? Why not just settle on Ethereum?
  • At a high level, Ethereum was not designed to be a lean base layer for L2 execution. Ethereum’s settlement latency significantly impacts L2 settlement time. Even with offchain DA layers, just 1MiB of data results in expensive transactions, which in the long run, is unsustainable. These bandwidth and latency constraints stem from consensus, finality, and noisy neighbor problems, that are all solved on our own settlement layer specifically designed to scale an app-centric execution layer.

How is this better than existing solutions?

Compared to Ethereum L2s

L2s are significantly bottlenecked by Ethereum as a settlement layer. The lack of composability primitives also make it such that each additional L2 further fragments the liquidity and UX. L2s and Ethereum also have an antagonistic relationship, both L2 and L1 operators seek to capture more value for themselves, leading to friction in adopting changes in the tech stack that lead to better overall product decisions.

Compared to other L1s

Almost all other L1s have monolithic execution and settlement (i.e. the L1 does both consensus and program execution). While this may be an improvement over Ethereum, our decoupled execution and settlement architecture can provide 10-100x improvements in terms of speed, compute, cost, and decentralization. Our execution layer also allows apps to scale horizontally. Meaning each app can scale to 100k+ tps individually, as opposed to other L1s, where the sum of all apps is limited to whatever the upperbound TPS of the chain is. This means that technically, there is no bound to what can be built on N1.