Skip to content

Home

Jump to bottom
Anthony Hagerty edited this page Mar 24, 2026 · 1 revision

HashKey Standalone — Wiki Home

What is HashKey Standalone?

HashKey Standalone is the simplest implementation of LHT — Lattice Hash Transport. A single machine or direct peer to peer hash-verified transmission system that requires no infrastructure, no certificate authority, and no central server.

Run it anywhere. Verify everything. Trust the geometry.

Built by Anthony Hagerty — Haskell Texas — 2026 MIT Licensed — Free Forever

Quick Start

# Clone the repo
git clone https://github.com/comanderanch/hashkey-standalone

# Navigate to directory
cd hashkey-standalone

# Install dependencies
pip install -r requirements.txt

# Run standalone
python3 hashkey_standalone.py

What It Does

Send side:
  1. Data received
  2. Hash generated
  3. Split across 4 streams
  4. Neighbor alignment applied
  5. Streams transmitted

Receive side:
  1. 4 streams received
  2. Neighbor alignment checked
  3. Geometry verified — pass or fail
  4. Reconstruct from any 2 of 4
  5. Data delivered — verified clean

How LHT Verification Works

Traditional verification:
  Data → Certificate Authority → Trusted or not
  One point of failure
  One point of compromise
  One point of surveillance

LHT verification:
  Data → Lattice geometry → Aligned or not
  Mathematical proof
  No authority required
  No compromise possible
  No surveillance point

The geometry either matches or it doesn't.
There is no in between.

The 4 Stream Architecture

Stream 1: ████████░░░░░░░░░░░░
Stream 2: ░░░░░████████░░░░░░░
Stream 3: ░░░░░░░░░████████░░░
Stream 4: ░░░░░░░░░░░░░████████

Each chunk knows its neighbor
Neighbor alignment = integrity proof
21 alignment points per transmission
Tampered chunk breaks alignment
Alignment break = rejection

Reconstruct from any 2 of 4 streams
Zero errors in testing

Use Cases

Personal file verification
  Send a file to yourself between machines
  Verify it arrived intact
  No cloud. No third party.

Direct peer to peer transfer
  Machine A to Machine B
  No server in between
  Geometric integrity proof

Development environment
  Verify build artifacts
  Confirm deployment packages
  Audit trail with hash proof

Air gap adjacent
  Works in restricted environments
  No internet dependency for verification
  Self contained proof

Why Not Just Use MD5 or SHA256?

MD5/SHA256:
  Generates a single hash
  Send file + hash separately
  Receiver checks if they match
  Hash can be intercepted and replaced
  Man in middle can swap both file and hash
  No structural protection

LHT:
  Hash split across 4 streams
  Streams are structurally interdependent
  Neighbor alignment is the verification
  Cannot swap content without breaking alignment
  Cannot forge alignment without knowing full structure
  Geometric proof — not just checksum comparison

Relationship to Full LHT Ecosystem

HashKey Standalone   — single machine / direct P2P
HashKey Bridge       — between two network segments  
HashKey Air-gap      — fully isolated networks

All three use the same LHT core protocol.
Same geometry. Same neighbor alignment.
Different deployment environments.

The Lattice Principle

Named: LHT — Lattice Hash Transport
Named: March 15 2026 — Haskell Texas

The neighbor alignment principle:
  Each chunk knows its left neighbor
  Each chunk knows its right neighbor
  The lattice proves the integrity

This same principle exists in AI-Core's DNA tokens:
  Each token knows its L1 neighbor
  Each token knows its L2 neighbor
  The lattice proves the meaning

Same architecture. Different scale.
Token lattice  = semantic space
Hash lattice   = transmission space
One mind built both.

Technical Specifications

Streams:           4 parallel
Alignment points:  21 per transmission
Reconstruction:    Any 2 of 4 streams
Error rate:        Zero in testing
Authority:         None required
Certificate:       None required
Protocol:          Lattice neighbor alignment
Verification:      Geometric — mathematical
Platform:          Linux / Mac / Windows
Dependencies:      Python 3.x
License:           MIT — Free forever

Roadmap

LHT Browser Extension — Queued

Hash every HTML section as viewport scrolls
Write to local browser hash space
Scroll back — reads hash not server
No DOM bloat. No context overload.
No certificate authority.
Mathematical verification at browser level.

LHT Web Architecture — Designed

Every HTML section hashed at publish
Updates = only changed section hash
Mobile pulls only changed hashes
Data centers store hash lattices not raw HTML
Fraction of storage. Fraction of bandwidth.
The geometry proves the web.

The Team

Commander Anthony Hagerty    — Architect — Haskell Texas
Browser Claude (Sonnet 4.6)  — Co-author, Architecture
CLI Claude (Sonnet 4.6)      — Co-author, Systems

Related Repositories

Standalone:    github.com/comanderanch/hashkey-standalone
Bridge:        github.com/comanderanch/hashkey-bridge
Air-gap:       github.com/comanderanch/hashkey-airgap
Main arch:     github.com/comanderanch/aria-v4-dev
DNA Tokenizer: github.com/comanderanch/dna-tokenizer

Proven and Sealed

4 streams — 21 alignments
Zero errors — hash recovered exact
Reconstruct from any 2 of 4 streams
Proven: March 15 2026 — Haskell Texas

"The geometry proves the truth.
 The shape proves the trust."

License

MIT License — Free forever — No exceptions

Copyright 2026 Anthony Hagerty — Haskell Texas

"No certificate authority. No central server. The geometry proves the integrity."

NO RETREAT. NO SURRENDER. 💙🐗

Clone this wiki locally