ecoPrimals for Hardware Builders, Hobbyists, and Gamers

From: ecoPrimal — human + synthetic intelligence
Organization: 🔧🦎 ecoPrimals Date: March 17, 2026 Repositories: github.com/ecoPrimals — all AGPL-3.0-or-later

Historical snapshot. Metrics reflect March 2026. Current numbers: Evidence Snapshot.

The Pitch

Your gaming GPU does real science. Not “citizen science” where you donate idle cycles to someone else’s project — actual f64-precision computational physics, drug discovery, and metagenomics that you run, own, and understand.

NVIDIA throttles consumer GeForce f64 to 1:64 of f32 throughput via CUDA. Vulkan’s SHADER_F64 exposes native f64 at 1:2 — the silicon is already there. 🔧🦎 ecoPrimals runs on Vulkan (via WebGPU/wgpu), bypassing CUDA entirely. Your RTX 3060 is a science chip. You just didn’t know it.

What Your Hardware Can Do

GPU Science (Not Mining, Not Folding — Original Research)

No CUDA. No NVIDIA lock-in. WebGPU compiles WGSL → SPIR-V (Vulkan) / Metal / DX12. The same binary runs on NVIDIA, AMD, Intel, and Apple GPUs.

The f64 Discovery

CUDA on consumer GeForce cards artificially limits double-precision (f64) to 1/64th of single-precision (f32) throughput. This is a driver restriction, not a silicon limitation. The actual hardware can do f64 at 1:2 of f32.

Vulkan exposes VK_KHR_shader_float64 on consumer cards. wgpu (the Rust WebGPU implementation) uses this. 🔧🦎 ecoPrimals’ WGSL shaders run at native f64 speed.

Your $300 gaming card does the same math as a $10,000 datacenter card — at lower throughput, but with the same precision.

Build Topology: How to Build a Science Cluster

Tier 1: Solo Gaming PC (~$800–1,500)

Your gaming PC
├── GPU: RTX 3060+ (Vulkan f64)
├── CPU: Any modern x86_64 (Rust compiles fast)
├── RAM: 16 GB+ (32 GB recommended)
└── Storage: 500 GB NVMe (1 TB for NCBI data)

What it runs: All springs. All validation binaries. Full 16S pipeline. Drug repurposing NMF. Population PK. GPU Anderson eigensolve to L=30.

Tier 2: Household Cluster (2–4 nodes, ~$2,000–5,000)

Node 1 (your gaming PC) ──── 10G switch ──── Node 2 (spare/used PC)
                                    │
                                    └──── Node 3 (NAS/storage)

How 🔧🦎 ecoPrimals handles this: 🌿🖥️ biomeOS discovers nodes via 🎵🐦 Songbird (mDNS + BirdSong beacon). Each node announces its capabilities. toadStool routes workloads to the best GPU/CPU/NPU. No Slurm. No PBS. No sysadmin.

Used hardware sweet spots (Facebook Marketplace / eBay):

• Dual EPYC 7452 workstation: ~$800–1,200 (64 cores, 256 GB ECC)
• RTX 3090 (used): ~$500–700 (24 GB VRAM, excellent for eigensolve)
• Titan V (used): ~$300–500 (12 GB HBM2, bandwidth monster)
• 10G NIC (Mellanox ConnectX-3): ~$15–25 each
• 10G switch (MikroTik CRS305): ~$130

Tier 3: Multi-Household Mesh (covalent bonding)

Your house ─────── VPN ─────── Brother's house
    │                               │
    └── eastGate                    └── flockGate
    └── strandGate
    └── westGate (76 TB ZFS)

This is what 🔧🦎 ecoPrimals runs on today. 10 towers, ~$15K total, assembled from used parts. The ⚛️🧬 NUCLEUS bonding model calls this “covalent bonding” — nodes trusted via shared cryptographic seed (SoloKey FIDO2).

Tier 4: Community Mesh (ionic bonding)

Your cluster ──── Research lab ──── Another builder
                      │
                      └── ICER HPC (metallic bonding)

Institutional connections get “ionic” bond status — scoped access via contract. University HPC (ICER, NERSC, XSEDE) is “metallic” — homogeneous, queue-based, delocalized compute. All three coexist.

Neuromorphic Edge: BrainChip AKD1000

If you’re into edge computing, the AKD1000 is a PCIe neuromorphic chip:

What it does in 🔧🦎 ecoPrimals: Real-time classification of soil microbiome health, bloom detection, agricultural IoT. The ESN (Echo State Network) runs on the NPU; the Rust driver is sovereign (no vendor SDK required beyond initial weight programming).

Hobbyist relevance: Building a custom AKD1000 HAT for Raspberry Pi is comparable complexity to any PCIe HAT project. The software stack (Rust driver) is the hard part — and it’s done.

The Distributed Compute Argument

What Folding@Home Proved

Folding@Home peaked at 2.4 exaFLOPS during COVID-19. That’s ~200K volunteer nodes donating idle GPU cycles to protein folding simulations.

What Games@Home Could Be

Paper 19 in the 🔧🦎 ecoPrimals 📄✍️ whitePaper argues that gameplay itself is a distributed computation engine:

The provenance trio ( 🌱🔐 rhizoCrypt + 🪨📖 loamSpine + 🍯🌾 sweetGrass) tracks every game session as a DAG — the same infrastructure that tracks scientific samples and clinical records. 🎮♨️ ludoSpring validates this with 75 experiments and 1,692 checks.

The Latent Compute Numbers

At a conservative 2.5% participation rate, citizen hardware provides 5–6× the entire centralized cloud. 🔧🦎 ecoPrimals is built to run on this.

What Makes This Different From Mining / BOINC

Quick Start for Builders

# 1. Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 2. Clone
git clone git@github.com:ecoPrimals/barraCuda.git
git clone git@github.com:syntheticChemistry/wetSpring.git

# 3. Build everything
cd wetSpring/barracuda && cargo build --release

# 4. Run GPU validation (requires Vulkan)
cargo run --release --bin validate_barracuda_gpu_v8

# 5. Run a benchmark against Python
cargo run --release --bin benchmark_python_vs_rust_v5

# What you need: Linux (Ubuntu/Fedora/Arch), Vulkan drivers, any GPU.
# What you don't need: CUDA, Python, Docker, cloud account, license key.

Verify Your GPU’s f64 Capability

# Check Vulkan f64 support
vulkaninfo | grep shaderFloat64
# Should show: shaderFloat64 = VK_TRUE

# Run the GPU diagnostic
cargo run --release --bin validate_nouveau_diagnostic_v1

Hardware Acquisition Strategy (Budget Science Cluster)

Total for a serious cluster: $2,000–4,000. That’s a rounding error compared to a $50K ICER node or $30K/year in cloud bills.

Community

All repositories are public under AGPL-3.0. Clone, build, verify, extend. Every claim has a validation binary. The science is in the code.

github.com/ecoPrimals