NDSR · deterministic runtime

Compute that
proves itself.

NDSR runs WebAssembly with byte-identical results on any CPU, 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 run on NDSR, Necter’s WebAssembly 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.

NDSR · the Necter runtime

One runtime.
Every result verifiable.

NDSR 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 WebAssembly

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 validators

Work runs redundantly in committees of miners. Validators reach BFT quorum on the receipt hash, re-execute a random share of rounds as audits and slash collateral for wrong or missing 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 Validators reach quorum on it
// 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 ed25519

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

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

    Validators finalize it

    Validators check the signed results and reach BFT quorum (3 of 4 on testnet). They re-execute a random share of rounds as audits. Wrong answers and missed work cost collateral.

  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. 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 WebAssembly for NDSR. 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 SDK docs: coming soon
use hivekit::prelude::*;

#[hive_export]
fn increment(input: Value) -> Result<Value, String> {
    let by = input["by"].as_i64().unwrap_or(1);
    let value = storage::get_json("count").unwrap_or(0) + by;
    storage::set_json("count", &value);
    emit("incremented", &json!({ "value": value }));
    Ok(json!({ "value": value }))
}
$ hivec build counter.rs → counter.hbc

Coming soon EVM compatibility

Solidity and EVM tooling,
on the Necter Network.

EVM compatibility is on the roadmap. The goal: deploy Solidity contracts next to NDSR workloads and use the wallets and tools EVM developers already know.

It is not live. Today Necter settles rewards on Ethereum Sepolia through standard ERC-20 contracts, and projects can already pay miners in any standard ERC-20 token. Details of EVM execution on Necter will be published before release.

  • Status Planned, not live
  • Contracts Solidity, standard EVM bytecode
  • Tooling Familiar EVM wallets and libraries
  • Today ERC-20 settlement on Ethereum Sepolia

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.

Download the whitepaper Get test NECTA
Token
NECTA (NCT)
Type
Utility + governance
Testnet
NECTA test token on Ethereum Sepolia
Mainnet
Necter native 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
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
    • · NDSR deterministic runtime
    • · HiveKit SDKs: Rust, Go, TypeScript, JavaScript, Python
    • · Mining platform: store, miner apps, contracts
  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

    • · Token Generation Event (TGE)
    • · Initial DePIN applications live
    • · Validator network establishment
  4. Phase 4 · 2027+ Planned

    Ecosystem expansion

    • · Full Hive product suite integration
    • · Enterprise DePIN partnerships
    • · 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 →