Deterministic execution · SecureWeave consensus · .hbc

Compute that
proves itself.

HiveKit compiles your code to Hive Bytecode (.hbc). NDSR, the Necter Distributed State Runtime, runs it with byte-identical results on any device, meters every instruction with gas and signs a receipt for every call.

Explore NDSR Open the store
Status
Connecting…
Validators
—
Quorum
—
Settles on
Ethereum Sepolia

Necter Network · powering decentralized intelligence

Where hardware meets intelligence.

Necter is a modular network for DePIN, AI agents, IoT and data sovereignty, and a decentralized compute network built like an app store. Developers list projects. Miners choose the ones they want to power and run them on hardware they already own. Validators check every result before anyone is paid.

From edge devices to autonomous AI agents, Necter provides the programmable infrastructure for a smarter, user-owned internet, optimized for compute, bandwidth, identity and privacy. Every contribution, whether data, compute or training, is rewarded through a convergent economic model.

Deterministic by design

Workloads ship as Hive Bytecode (.hbc) and run on NDSR, Necter’s deterministic runtime. The same module gives byte-identical results on x86, ARM64 and 32-bit ARM, so answers from different devices can be compared exactly.

Verified, not trusted

Every round runs in a committee of miners. Validators reach BFT quorum, re-execute a random share of rounds as audits, and slash collateral for wrong or missing results.

Paid on-chain

Rewards settle in NECTA from each project’s on-chain vault. On testnet that is Ethereum Sepolia, and claims are gasless: miners never need ETH. Mainnet moves to Necter EVM, our own hybrid chain.

NDSR · Necter Distributed State Runtime

One runtime.
Every result verifiable.

NDSR, the Necter Distributed State Runtime, is the deterministic engine at the heart of Necter. It is what lets many different machines run the same job and agree, to the byte, on the answer, so honest work can be proven and paid.

A glowing hexagonal core, the Necter runtime

01

Deterministic Hive Bytecode

The same module and input give byte-identical output on x86, ARM64 and 32-bit ARM. A portable interpreter engine keeps phones and tablets on exactly the same results as servers.

02

Gas on every instruction

Execution is metered with fuel, so every call has a known, bounded cost. A deterministic stack limit means runaway code fails the same way everywhere.

03

Signed receipts

Each call produces a receipt (module, function, input, output and event hashes, gas used, success) hashed with keccak256 and signed with the node’s ed25519 key. Validators vote on receipts, alongside module state roots, and payouts are built from them.

04

Committees and SecureWeave

Work runs redundantly in committees of miners. Validators finalize results with SecureWeave, NDSR’s Byzantine-fault-tolerant consensus, re-execute a random share of rounds as audits and record evidence that slashes collateral for wrong results.

05

State and composition

Every module gets its own persistent key-value state, and modules can call each other with hive.call, across languages, inside the same deterministic execution.

06

Many languages, one format

HiveKit compiles Rust, Go, TypeScript, JavaScript and Python to content-addressed .hbc modules. The address of a module is the hash of its code.

Anatomy of a call

  1. 1 Load the .hbc module by its address
  2. 2 Execute __hive_entry with metered gas
  3. 3 Commit state, emit events
  4. 4 Hash and sign the receipt
  5. 5 SecureWeave finalizes it at validator quorum
// receipt (illustrative values)
{
  "v": 1,
  "module_address": "0x9f3a…c2e1",
  "function": "increment",
  "input_hash": "0x51d0…7a3b",
  "output_hash": "0xc4e8…1f09",
  "events_hash": "0x0a7f…e2d4",
  "gas_used": 1204551,
  "success": true
}
// receipt_hash = keccak256(canonical_json(receipt)), signed with ed25519

Languages: Rust · Go · TypeScript · JavaScript · Python. Engines: native on 64-bit hosts, the portable engine on iOS and 32-bit ARM, with identical receipts.

See how NDSR works, step by step

The Necter Mining Store

An app store,
but you get paid.

The store is where developers list mining projects and miners choose what their devices work on. Every project is an NDSR workload with its own on-chain vault, so what you see listed is what pays.

Open the store Browse projects

  1. 01

    Discover

    Browse projects by category. Each listing shows what it computes, what it pays, the committee size and the hardware it needs.

  2. 02

    Check your device

    The store and the miner check compatibility before you commit: CPU, memory, storage and device class.

  3. 03

    Subscribe

    Bond test NECTA as collateral (gasless) and your device starts receiving tasks for that project.

  4. 04

    Earn and claim

    Finalized rounds earn rewards from the project’s vault each epoch. Claims are batched and gasless.

Inside the store

  • · Project pages: economics, requirements, reviews
  • · Hardware compatibility checker
  • · My Mining: devices, subscriptions, earnings
  • · Explorer: rounds, epochs, receipts
  • · Leaderboards and badges
  • · Faucet for test NECTA
  • · Developer console
  • · Wallet sign-in (SIWE)
Learn how the store works →

Listed on testnet now

See all →
  • Loading projects…

How mining works

From your device
to the chain, in four hops.

How a mining round flowsA device sends work to a committee of miners, the committee's signed results go to four validators, and validators settle rewards on-chain.DeviceCommitteeValidators · 3 of 4NECTA payout

  1. 01 · Device

    Your device picks up a task

    The miner keeps one outbound connection to the network, so there are no ports to open, even on a phone. It accepts tasks only for the projects you joined and only within the limits you set for battery, heat and network.

  2. 02 · Committee

    A committee runs it

    Each round goes to a committee of miners drawn by collateral- and reputation-weighted sortition. Every member executes the same module in NDSR and signs its result.

  3. 03 · Validators

    SecureWeave finalizes it

    Validators check the signed results and finalize them with SecureWeave, Necter’s BFT consensus (3 of 4 on testnet). They re-execute a random share of rounds as audits. Wrong answers cost collateral; missed work costs reputation. During the testnet the Necter team operates the validator set; validator applications open at mainnet.

  4. 04 · Payout

    Rewards land on-chain

    At the end of each epoch, validators sign a reward receipt and the project’s vault pays out in NECTA or the project’s own token. A relayer covers gas, so claiming is free.

For miners

Mine from the phone
in your pocket.

Browse projects in the store, check that your hardware fits, bond test collateral and start. The miner app shows what you run and what you earn, and it is where you claim your NECTA.

Download the miner Browse projects
Necter's bee mascot
The Necter bee

Built to be a good guest on your device

  • Only while charging

    Phones mine on charge by default and pause below 40% battery.

  • Keeps cool

    New work stops when the device runs warm, and everything stops if it gets hot.

  • Wi-Fi first

    Metered and cellular data stay off unless you turn them on.

  • Your keys

    An embedded wallet is created on the device, or bring your own payout address.

Every limit is yours to change. Servers and desktops run without the phone limits, and the miner never needs an inbound port.

Build on the Necter Network

Ship a workload.
Get a global fleet.

HiveKit compiles your code to Hive Bytecode (.hbc), which NDSR executes deterministically on any device. Publish it to the store and any device on the network can run it, with results that are checked and paid for automatically.

  • Rust
  • Go
  • TypeScript
  • JavaScript
  • Python

  1. 01

    Write

    A module in Rust, Go, TypeScript, JavaScript or Python with HiveKit.

  2. 02

    Build

    Compile to a content-addressed .hbc module that NDSR runs deterministically, with metered gas.

  3. 03

    Publish

    Register gaslessly and list it in the store with its requirements, committee size and reward model.

  4. 04

    Reward

    Fund the project vault in NECTA or your own ERC-20 token. Miners subscribe; validators keep every round honest.

Open the developer console Read the docs · 10-minute quickstart

Stores, marketplaces, ticketing, games: see what you can build

use hivekit::prelude::*;

/// increment {"by": n}: add to the counter, persist it, emit an event.
#[hive_export]
fn increment(input: Value) -> Result<Value, String> {
    let by = input["by"].as_i64().unwrap_or(1);
    let count = storage::get_json::<i64>("count").unwrap_or(0) + by;
    storage::set_json("count", &count);
    emit("incremented", &json!({ "count": count }));
    Ok(json!({ "count": count }))
}

hive_module!(increment);
$ hivec build → dist/counter.hbc

Install Rust tooling

$ curl -fsSL https://necter.network/install.sh | sh -s -- rust

In development Necter EVM · OP Stack + ZK

Solidity and NDSR,
side by side.

Necter EVM is the hybrid execution engine we are building for mainnet. It pairs the OP Stack’s Ethereum-equivalent EVM with zero-knowledge proof finality, so traditional Solidity contracts run next to NDSR modules on one network, under one roof.

Built for speed: blocks are final once a ZK proof verifies, not after a 7-day challenge window. Our goal is to make Necter the fastest place to run Solidity and NDSR together.

Necter EVMSolidity contracts on the OP Stack EVM and NDSR Hive Bytecode modules both feed the Necter EVM hybrid engine. A zero-knowledge validity proof finalizes the result on Necter.Solidity contractsOP Stack · EVM-equivalentNDSR · .hbc modulesminer committeesNecter EVMhybrid engineZKvalidityproofno challenge windowFinalon Necter

  • OP Stack

    EVM tooling, unchanged

    Ethereum-equivalent execution from the OP Stack. Write Solidity, test with Foundry or Hardhat, sign with the wallets you already use.

  • NDSR

    Compute alongside

    Contracts sit next to deterministic .hbc modules that miners run through the Mining Store, verified by SecureWeave.

  • ZK

    Final by proof

    Validity proofs give fast, cryptographically final settlement instead of waiting out an optimistic challenge window.

Today · live

Public testnet on Ethereum Sepolia

NECTA, project vaults, staking and the project registry run as standard contracts on Sepolia while NDSR does the compute. Projects can already pay miners in any standard ERC-20 token.

Read the EVM plan See the roadmap

Planned, not live. There is no Necter EVM chain ID, RPC endpoint, launch date or benchmark yet; details will be published before release.

The network, live

Watch the testnet breathe.

Read straight from the public RPC at testnet-rpc.necter.network.

Connecting…
Validators online
—
Quorum
—
Projects listed
—
Miners online
—
Devices connected
—
Collateral bonded
—

Validators

  • Americas
  • Europe
  • Asia
  • Africa

Settlement: Ethereum Sepolia

In the store

See all →
  • Loading projects…

One token. Every layer.

NECTA, the convergent
fuel of the hive.

$NECTA (NCT) is the native utility, governance and incentive token of the Necter ecosystem. From running compute on DockHive to deploying agents on TIWA, NECTA coordinates value, access and accountability across products, networks and people. You earn through contribution, not speculation.

Whitepaper v1 · overview Technical paper v2 Get test NECTA
Token
NECTA (NCT)
Type
Utility + governance
Total supply
617,400,000 (planned)
Testnet
NECTA test token on Ethereum Sepolia
Mainnet
Necter EVM, our hybrid chain (planned)
Governance
DAO-enabled

  • Compute payments

    Pay for work done on the network and reward the devices that did it.

  • AI agent microtransactions

    Small, frequent payments between agents, services and the people who run them.

  • Data vault access

    Gate and monetise access to data, with the owner in control.

  • Device staking and validation

    Collateral for miners and stake for validators keeps every round honest.

  • Governance and upgrades

    Holders review listings, vote on proposals and steer protocol upgrades.

  • Cross-product identity

    One token and identity layer across the Hive ecosystem: DockHive, TIWA and more.

Kaprekar’s constant · 6174 flow

Designed for economic balance

Inspired by Kaprekar’s 6174 and honeycomb modularity, NECTA enforces sustainable token flow through staking, contribution-based mining, burn-to-use logic and dynamic supply locking.

  • Modular

    Like a honeycomb: every project is a functional cell.

  • Convergent

    Like Kaprekar’s 6174: flows naturally into equilibrium.

  • Governed

    DAO-enabled, with burn-and-lock mechanisms for control.

  • Scalable

    Multi-chain ready, with proof-of-usage token minting.

Smart contracts: agent payments, compute credits, vault access, dynamic supply locks and DAO voting.

Tokenomics snapshot

Planned allocation

Planned NECTA allocation by category
CategoryShare
Mining reserve65%
Ecosystem incentives15%
Hive treasury10%
Liquidity provision4.6%
Presale3.24%
Founding team1%
DAO reserve0.76%
Public listing0.4%

From the NECTA whitepaper. Planned and subject to change before mainnet. Testnet NECTA has no monetary value.

NECTA Genesis Protocol · early access

Mint a Genesis Token.
Claim NECTA after TGE.

Get early access to NECTA by minting a NECTA Genesis Token (NGT), a non-transferable voucher for $NECTA airdrops. Legacy DockHive users can convert old assets; new users complete tasks to mint their NGT and join the ecosystem.

Legacy users

  • Convert old DHT tokens or DockHive NFTs
  • 1 DHT = 4 NECTA; NFTs earn a rarity bonus
  • Mint your NGT to claim a future NECTA allocation

New users

  • Complete community quests
  • Mint your NGT for a vested NECTA airdrop
  • Referrals and top task completers earn bonuses
  • Referrals tracked on-chain; weekly leaderboard and AMAs
Open Genesis Protocol
Campaign allocation
0.5% of NECTA supply (~3,087,000)
Vesting
6-month cliff, 12-month linear
Steps
Complete tasks → mint NGT → track → claim after TGE

Roadmap

From concept to world-class infrastructure.

Each phase is a step toward decentralizing global infrastructure. Here is where we are.

  1. Phase 1 · Q4 2025 – 2026 Completed

    Foundation and development

    • · Team assembled, vision defined
    • · Architecture and protocol design
    • · Layer 2 architecture designed, OP Stack evaluated
    • · NDSR deterministic runtime
    • · HiveKit SDKs: Rust, Go, TypeScript, JavaScript, Python
    • · Mining platform: store, miner apps, contracts
    • · Developer documentation
  2. Phase 2 · Live now Live

    Public testnet and ecosystem preparation

    • · Public testnet on Ethereum Sepolia
    • · Four validators in four regions
    • · Necter Mining Store and miner apps
    • · Community testing and developer onboarding
    • · Token economics finalization
  3. Phase 3 · Planned Planned

    Mainnet launch

    • · Mainnet on Necter EVM
    • · Final security audits
    • · Token Generation Event (TGE)
    • · Exchange listings
    • · Initial DePIN applications live
    • · Validator network establishment: applications open
  4. Phase 4 · 2027+ Planned

    Ecosystem expansion

    • · Full Hive product suite integration
    • · Enterprise DePIN partnerships
    • · DAO governance implementation
    • · Advanced DePIN features
    • · Cross-chain expansion
    • · Global infrastructure

Public testnet

The hive is open.
Come build it with us.

Testnet NECTA has no monetary value. It exists so you can try everything end to end, from publishing a project to claiming rewards, before mainnet.

Open the store Download the miner

  1. Step 1

    Get the miner

    Android or macOS today, or the server CLI.

    Download →

  2. Step 2

    Grab test NECTA

    The faucet sends test tokens for collateral. No ETH needed.

    Open the faucet →

  3. Step 3

    Join a project

    Pick one in the store, bond, and your device starts working.

    Browse projects →

Community

Join the Necter community

Get testnet updates, help from the team and other builders, and early access to what ships next.

Telegram Discord