NMX-NeuroMesh

NMX-NeuroMesh is an experimental Python codebase for exploring AI-assisted mining, RF-derived entropy, and lightweight peer coordination in a blockchain-style node loop.

This repository currently contains prototype node implementations, a small GRU export script, and prebuilt ONNX and TensorRT plan artifacts. It is best understood as a research sandbox, not a finished cryptocurrency client or production blockchain.

What Is In This Repo

The project centers on a series of neuromesh_node*.py iterations that combine:

• JAX-accelerated scoring and batch hashing
• pseudo-random or SDR-backed RF signal capture
• simple proof-like entropy generation
• UDP broadcast-based peer discovery / signaling
• iterative block-mining loops with a moving previous-hash state

The latest script in this workspace, neuromesh_node_v13.py, adds an optional SoapySDR/LimeSDR path for real RF receive/transmit behavior while preserving a fallback path that uses generated random data when SDR hardware is unavailable.

Repository Contents

Key files currently included:

• neuromesh_node.py: early single-node NeuroMesh prototype with RF proof simulation and a basic mining loop
• neuromesh_node_v2.py to neuromesh_node_v13.py: iterative node experiments and protocol revisions
• export_gru_onnx.py: exports a simple PyTorch GRU model to ONNX
• gru_model.onnx: exported ONNX GRU artifact
• gru_model.onnx.data: ONNX external tensor data
• gru_gpu.plan, gru_dla0.plan, gru_dla1.plan: TensorRT engine artifacts

Current Architecture

At a high level, the current node prototypes follow this pattern:

1. collect or simulate RF-derived signal data
2. derive a lightweight AI or entropy signal from that input
3. score batches of nonce candidates with JAX
4. accept the best candidate once it falls below a configured difficulty threshold
5. emit a block/hash announcement to peers over UDP broadcast
6. optionally trigger RF transmit when SDR hardware is active

This is a prototype workflow for experimentation. It does not yet implement the guarantees expected from a full blockchain network, such as durable consensus, peer authentication, chain validation, mempool handling, wallet support, or persistence.

Requirements

The code in this repository assumes a Linux-like environment and Python 3.

Common Python dependencies used by the node scripts include:

• numpy
• jax
• jaxlib
• torch for ONNX export

Optional hardware integration dependencies:

• SoapySDR
• a supported SDR device and driver stack, such as LimeSDR

If you do not have SDR hardware available, the node falls back to generated random input for RF data paths.

Quick Start

Install the Python dependencies you need in your environment, then run one of the node prototypes directly.

Example:

python3 neuromesh_node.py

For the later SDR-capable prototype:

python3 neuromesh_node_v13.py

If SoapySDR or compatible hardware is not available, neuromesh_node_v13.py will continue in fallback mode using generated RF-like data.

Exporting The GRU Model

To regenerate the included ONNX model:

python3 export_gru_onnx.py

This exports a minimal GRU network to gru_model.onnx for downstream experimentation with ONNX or TensorRT workflows.

Important Notes

• This repository is experimental and prototype-oriented.
• The networking layer is currently simple UDP broadcast messaging, not a hardened P2P stack.
• The mining and entropy mechanisms are research code and should not be treated as production cryptography.
• Included TensorRT plan files are environment-specific artifacts and may not be portable across systems.

Roadmap Ideas

Natural next steps for the project would be:

• define a stable block format and chain validation rules
• add persistent storage for blocks and node state
• replace broadcast-only networking with explicit peer management
• separate protocol, mining, RF, and model code into modules
• document hardware setup for SoapySDR/LimeSDR
• add reproducible environment and dependency instructions

Status

NMX-NeuroMesh is an active prototype repository for AI + RF + hashing experiments. The code demonstrates concepts and implementation direction, but it is not yet packaged or documented as a production-ready network node.