What is NockApp?

Connecting your apps to Internet capital.

NockApp is a framework which enables developers to build formally provable blockchain applications that execute efficiently both on-chain and off-chain.

• @nockchain, the NockApp framework

The NockApp framework is a general-purpose platform which is used with Nockchain to write and deploy sovereign applications. Developers can build decentralized exchanges, gaming applications, or financial protocols that inherit Nockchain's security guarantees while maintaining their own consistency rules.

• zorp-corp/nockchain

Developers will encounter NockApp as a two-component architecture, a runtime or virtual machine program which is internally running a Nock ISA program. The runtime is written in Rust and provides a Nock evaluator and input/output drivers. The kernel is written in the Nock ISA using a higher-level language like Hoon or Jock and contains the provable application logic.

NockApp's architecture solves the traditional tradeoff between formal verification and performance. The kernel contains your core application logic written in Nock ISA—making it formally provable and suitable for zero-knowledge proofs. The runtime is a Rust virtual machine that runs Nock and handles the messy I/O driver details: communicating with Nockchain, file operations, networking, acting as a REPL, etc. This separation means you get mathematical guarantees about your core logic while maintaining the speed and flexibility needed for practical applications.

What is Nock ISA?

NockApp interactions take place through a well-defined interface to query ("peek") and modify ("poke") the program state as a Nock ISA noun. NockApps communicate with each other using gRPC, which allows for local and remote discoverability and interaction.

NockApp apps are state machines that retain their state from last execution (unless reset), with durable persistence of the Nock ISA program state—no need to worry about databases, files, object-relational models, or serialization. The first apps that most users encounter are Nockchain itself (nockchain) and its associated wallet (nockchain-wallet), which demonstrate this architecture in practice.

Several templates are available for the NockApp framework through the Nockup developer toolkit, currently in pre-release development.

Developers use the proven formal characteristics of the Nock ISA together with NockApp's fast commoditized execution for zero-knowledge proofs to produce novel and secure blockchain applications. This combination enables applications that are both mathematically sound and practically performant.

Kernel

The kernel is written in a language that compiles to the Nock ISA. At the time of writing (October 2025), this means Hoon as a full systems language. (The Jock scripting language is in development but not yet ready for use in kernels.) The kernel is a Nock noun as a state machine, including a standard structure and an associated state (which is the deterministic result of events applied to the kernel.)

A kernel presents several entry points as a standard interface. (We write these with a + to accord with Hoon's usage.)

• +load is used in upgrades, allowing the kernel to update itself in-place.

• +peek grants read-only access to a kernel; sometimes this is called a scry. A peek requests data at a specific path. This is a lightweight way to obtain state information.

• +poke accepts and processes events, returning a list of events and an updated state. A poke event includes arbitrary nouns.

The Nock ISA is a "solid-state" language: the new state is automatically maintained by the NockVM in the runtime. Since the state is a Nock ISA noun, it is the deterministic, portable record of its event history.

Runtime

The runtime consists of a NockVM and a set of input/output drivers which may be selected according to the developer's needs. Nockup templates reduce the need for developers to write any Rust code directly.

NockVM is a general Nock ISA execution library, designed for fast 64-bit execution of Nock ISA code.

The NockApp framework provides stock drivers for file I/O, HTTP I/O, gRPC I/O, etc. These are included explicitly in the Rust file, which means in practice most NockApp developers will prefer to work from existing templates.

Communication with Nockchain (either locally or remotely) is brokered by the gRPC driver.

Intents

NockApp applications express intents (declarative conditions) over the available facts of the chain's state. Off-chain logic processes intents and generates proofs which are submitted to the miner's transaction pool for inclusion in a block. Nockchain miners verify the aggregated proofs, update the chain state atomically, and post the new heaviest block as truth. This also enables easier composability across independent applications: one application can watch another's state and behaviors from block to block.

You can think about this similar to a layer-2 rollup on certain smartchains, but with different motivations and benefits. For a gas-based chain like Ethereum, higher transaction volume leads to network congestion and a need to increase gas costs to economically throttle transactions and keep the network usable. This style of rollup summarizes many transactions into one, confirms their validity, and posts them to the layer-1 blockchain.

Because a Nockchain block consists of the hashes of consistent programs rather than the entire computation, NockApp applications do not need to optimize for on-chain computation. With an elastic block size, Nockchain is furthermore robust: popularity is not its own defeat as for throughput-limited chains. Because of intents and the proven consistency of the entire chain state at each block height, a mechanism like optimistic rollups are furthermore unnecessary. (Nor is a StarkNet-style ZK rollup necessary because the entire chain enforces zero-knowledge-proven consensus.) Off-chain computation with on-chain verification means that gas optimization at every line of code is unnecessary.

Instead, sovereign applications built using NockApp check and post their own consistency checks over the chain's global state. You can think of this as a private consensus, but the upshot is similar to naive rollups: an internal but real consensus specific to the application and its requirements. And unlike many L2 consensus states, the base state of the application can be recovered directly from Nockchain's global state.