---
license: apache-2.0
tags:
- knowledge-graph
- wiki-data
- wikipedia
language:
- en

pretty_name: GetNID — Neurofold Identity Registry v1.0
size_categories:
- 1M<n<10M
---
```
# GetNID — Neurofold Identity Registry v1.0

**A deterministic, cryptographically-immutable identifier registry for 6.7 million Wikipedia concepts.**

GetNID mints a canonical **Neurofold ID (NID)** for every resolved Wikipedia article, bridging human-readable titles and Wikidata QIDs through a trustless, serverless resolution protocol. The registry is designed to function as foundational namespace infrastructure for decentralized knowledge systems.

---

## What is a NID?

A Neurofold ID is a deterministic 13-character identifier derived directly from the SHA-256 hash of a concept's Wikidata QID.

```
"Mathematics"  →  Q395  →  N5336CE94E17E
"Albert Einstein"  →  Q937  →  N6F2A8C14B301
```

NIDs are **permanent**, **content-addressed**, and **collision-resistant**. They require no central authority to issue or resolve.

---

## Resolution Architecture

The registry implements a **double-sharding scheme** for O(1) lookup with no index scans, no search, and no server-side compute.

```
Title lookup (double-hop):
  sha256(normalize(title))[:2] % 256   →  router shard  →  NID
  NID[1:5] % 8192                      →  data shard    →  record

QID / NID lookup (single-hop):
  sha256(QID)[:4] % 8192               →  data shard    →  record
  NID[1:5] % 8192                      →  data shard    →  record
```

| Layer | Shards | Purpose |
|---|---|---|
| Data shards | 8,192 | `ledger(nid, qid, title, lang)` |
| Router shards | 256 | `routes(key_hash, target_nid)` |

All shards are static SQLite files (~100KB each). The full registry is ~1.5GB. Every shard is independently verifiable against a cryptographic `manifest.json` generated at genesis time.

---

## Live Demo

**[getnid.org](https://getnid.org)** — resolve any Wikipedia title, QID, or NID in the browser.

Resolution runs entirely client-side via a Web Worker using sql.js (SQLite compiled to WebAssembly). Resolved shards are cached locally via the browser's **Origin Private File System (OPFS)**, enabling zero-latency offline resolution after first access. Users can opt into a full global sync to permanently mirror the entire registry locally.

---

## Dataset Structure

```
v1/
├── manifest.json          # SHA-256 hash of every shard (trustless verification)
├── meta.json              # Version, genesis timestamp, master checksum, metrics
├── shards/
│   ├── shard_0000.db      # SQLite — ledger table
│   ├── shard_0001.db
│   └── ... (8,192 total)
└── routers/
    ├── router_000.db      # SQLite — routes table
    ├── router_001.db
    └── ... (256 total)
```

### `ledger` schema (data shards)
```sql
CREATE TABLE ledger (
    nid   TEXT PRIMARY KEY,  -- e.g. N5336CE94E17E
    qid   TEXT UNIQUE,       -- e.g. Q395
    title TEXT,              -- e.g. Mathematics
    lang  TEXT               -- e.g. en
);
```

### `routes` schema (router shards)
```sql
CREATE TABLE routes (
    key_hash   TEXT PRIMARY KEY,  -- sha256(norm_title)[:16]
    shard_id   INTEGER,
    norm_title TEXT,
    target_nid TEXT
);
```

---

## Usage

### Python (local resolution)

```python
from getnid.registry import LocalRegistryClient
from pathlib import Path

client = LocalRegistryClient(Path("./v1"))

# Resolve by title
client.get_by_title("Mathematics")
# → {"nid": "N5336CE94E17E", "qid": "Q395", "title": "Mathematics", "lang": "en"}

# Resolve by QID
client.get_by_qid("Q42")
# → {"nid": "N...", "qid": "Q42", "title": "Douglas Adams", "lang": "en"}

# Resolve by NID
client.get_by_nid("N5336CE94E17E")
# → {"nid": "N5336CE94E17E", "qid": "Q395", "title": "Mathematics", "lang": "en"}
```

### Direct shard query (any language)

```python
import hashlib, sqlite3

def resolve_qid(qid: str, shard_dir: str) -> dict:
    h = hashlib.sha256(qid.upper().encode()).hexdigest().upper()
    shard_id = int(h[:4], 16) % 8192
    db_path = f"{shard_dir}/shard_{shard_id:04d}.db"
    with sqlite3.connect(db_path) as conn:
        row = conn.execute(
            "SELECT nid, qid, title, lang FROM ledger WHERE qid = ?",
            (qid.upper(),)
        ).fetchone()
    return dict(zip(["nid", "qid", "title", "lang"], row)) if row else None
```

### JavaScript / Browser

```javascript
const sha256 = async (text) => {
    const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
    return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2,'0')).join('').toUpperCase();
};

async function resolveQID(qid) {
    const hash = await sha256(qid.toUpperCase());
    const shardId = parseInt(hash.slice(0, 4), 16) % 8192;
    const fileName = `shard_${String(shardId).padStart(4,'0')}.db`;
    // Fetch shard, query with sql.js
}
```

---

## Metrics

| Metric | Value |
|---|---|
| Minted NIDs | ~6.7M |
| Languages | en (v1.0) |
| Data shards | 8,192 |
| Router shards | 256 |
| Avg shard size | ~100 KB |
| Total payload | ~1.5 GB |
| Lookup complexity | O(1) |

---

## Licensing

| Component | License |
|---|---|
| Registry code & protocol | [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) |
| Ledger data (derived from Wikidata) | [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) |

Wikidata content is made available by the Wikimedia Foundation under CC BY-SA 4.0. Use of the registry data is subject to those upstream terms.

---

## Repository

[github.com/neurofold/getnid](https://github.com/neurofold/getnid)

---

## Citation

```bibtex
@misc{getnid2026,
  author  = {Larson, JB},
  title   = {GetNID: Neurofold Identity Registry v1.0},
  year    = {2026},
  url     = {https://huggingface.co/datasets/Neurofold/getnid},
  note    = {Deterministic identifier registry for 6.7M Wikipedia concepts}
}
```