RAM Cloud

   

📖 Table of Contents

• Overview
• The Problem & The Solution
• Features
• How It Works
• The RAM Console
• Payments
• Earning — Share Your GPU
• Proof of Work
• API Reference
• Tech Stack
• Quick Start
• Environment Variables
• Project Structure
• Deployment
• Roadmap
• FAQ

🧩 Overview

RAM Cloud is a decentralized network for memory & compute on Base. Rent a node and run real workloads, or share your machine's spare capacity and earn real USDC for every task it handles. Rentals are priced per gigabyte-hour and paid in ETH or USDC; worker payouts settle on-chain and are verifiable on Basescan.

Every rented node speaks the Redis protocol — drop it into your stack as a cache, session store, scratch space, or rate-limiter — and can run compute tasks with the RUN command.

The whole thing is a Next.js 16 app with MetaMask wallet auth, real ETH/USDC payments on Base, a server-backed memory console, real in-browser GPU compute (WebLLM/WebGPU), proof-of-work verification, and real USDC worker payouts.

💡 The Problem & The Solution

The problem. Cloud compute and memory are expensive, billed in rigid reserved blocks, and locked to a few centralized providers. Meanwhile billions of gigabytes of RAM and countless idle GPUs sit unused in gaming rigs, home servers, and data-center overflow — doing nothing.

The solution. RAM Cloud connects the two. Providers share genuinely idle capacity straight from the browser; developers rent exactly what they need by the hour, settled trustlessly on Base.

Traditional cloud	RAM Cloud
Monthly reserved blocks	Pay per GB-hour
One vendor, lock-in	Decentralized mesh of nodes
Fiat billing, contracts	Crypto-native — ETH / USDC on Base
Trust the provider	Proof-of-work + on-chain payouts

✨ Features

🛒 Marketplace Browse and filter nodes by DDR generation, ECC, frequency, region, health score, price, and live benchmarks. Sort by recency, health, uptime, price, or benchmark. 💸 Real Payments Rent priced per GB-hour, payable in ETH or USDC on Base via MetaMask. Live ETH→USD conversion, and a Basescan link for every transaction. 🖥️ Earn From Your GPU Click Start Worker on the Earn page — a compute node spins up in your browser tab via WebGPU, no install. Your machine handles real tasks and you earn USDC per job. 🧠 Live RAM Console Every rental opens a real, server-backed Redis-style console. SET/GET travel to the server and persist in real memory namespaced by your API key — plus RUN to offload a compute task to the node.

🛡️ Proof of Work Nodes are audited with hidden verification challenges, a timing floor, and slashing — a worker can't fake its way to a payout. 🏦 Real USDC Payouts Connect a wallet, sign once to register, and withdraw real USDC on Base on demand. Every payout is an on-chain tx with a Basescan link, shown in your dashboard. Daily caps keep the treasury safe. 🎁 Free to Try Every visitor gets $1 of credit on a shared node — no wallet, no signup. Run real tasks in seconds on the Try page. 📈 Live Network & Docs A real-time protocol dashboard (TB online, active nodes, leases, volume), a secondary market for active leases, reviews, and full docs.

🧠 How It Works

   Renter (browser)                    Provider (browser)
   ┌───────────────┐                   ┌──────────────────┐
   │ Marketplace   │                   │ Browser Worker   │
   │ RAM Console   │                   │ (WebGPU compute) │
   └──────┬────────┘                   └─────────┬────────┘
          │  run task                  heartbeat │  poll / result
          ▼                                       ▼
        ┌───────────────────────────────────────────┐
        │              Orchestrator                  │
        │  • live-node registry (heartbeats)         │
        │  • routes each task to an idle worker      │
        │  • proof-of-work audits + slashing         │
        │  • managed fallback when no worker is live │
        └────────────────────┬───────────────────────┘
                             │  settle
                             ▼
                     Base  ·  ETH / USDC

1. Provide — anyone goes live in one browser click. A node loads onto their GPU (WebGPU) and joins the mesh.
2. Route — the orchestrator assigns each task to an idle node, audits it for honesty, and relays the result. If no worker is online, a managed fallback handles it so renters are never stuck.
3. Settle — renters pay in ETH/USDC; workers earn per task and withdraw real USDC — all on Base.

💻 The RAM Console

Each rental gets a live console backed by /api/ram — a real in-memory key-value store, namespaced per rental by API key. Data you SET persists server-side and returns on GET.

Command	Description
PING [msg]	Health check → PONG
SET key val [EX secs]	Store a value, optional TTL
GET key	Retrieve a value
DEL key …	Delete one or more keys
INCR key	Atomically increment an integer
TTL key	Seconds until a key expires
KEYS · DBSIZE · INFO	Inspect the namespace
FLUSHALL	Clear the namespace
RUN <task>	Offload a compute task to the node
HELP / CLEAR	Console helpers

> SET session:abc alice
OK                                   0.04ms
> GET session:abc
"alice"                              0.05ms
> RUN summarize the redis use-cases for a cache
A cache stores hot data in memory for sub-ms reads…   · served by a community GPU node

💸 Payments

• Currencies — pay in ETH (native) or USDC (ERC-20) on Base.
• Wallet — connect MetaMask; the app switches/adds the Base network automatically.
• Pricing — every listing is priced per GB-hour. Total = GB × hours × price, with an optional burst overflow reserve.
• Settlement — funds move on Base; every tx links to Basescan.
• Escrow (roadmap) — on-chain escrow with SLA-based auto-refund is planned; today payments transfer directly to the treasury.

🏦 Earning — Share Your GPU

Become a provider in one click — no install, no signup.

1. Go live — open the Earn page → Start Worker. A compute node loads onto your GPU in the tab (WebGPU; ~0.9 GB model, cached after first load).
2. Earn per task — your machine handles real jobs from the network. Earnings accrue live.
3. Get paid — connect a wallet, sign once (free, no gas) to register your payout address, then Withdraw real USDC on Base.

Payout safety limits

Setting	Value
Per task	$0.04
Minimum withdrawal	$0.50
Daily cap	$1.00 per wallet
Overall ceiling	the treasury's USDC balance

Every payout is an on-chain transaction with a Verify on Basescan link in your dashboard, so earnings are independently verifiable.

Have a dedicated machine? The agent/ directory holds a Node CLI for always-on nodes (advanced).

🛡️ Proof of Work

Because nodes report their own results, the network verifies the work before paying:

• Hidden audits — the orchestrator randomly slips in tasks it already knows the answer to, indistinguishable from real jobs.
• New nodes are vetted first — you can't earn-and-withdraw until you've passed a check.
• Timing floor — results returned faster than real compute is possible are rejected.
• Slashing — repeated failures flag the node, zero its accrued earnings, and block withdrawals.

No cheap method proves a specific model ran (that needs zkML/TEE — on the roadmap), but this makes faking cost real work, and the daily payout cap is the hard backstop.

🔌 API Reference

Route	Method	Purpose
/api/ram	POST	Real KV memory store + RUN task dispatch (worker or hosted fallback)
/api/worker	GET · POST	Worker register / poll / submit result · register payout · withdraw
/api/listings	GET · POST · DELETE	Shared, server-side node registry
/api/providers	GET	Provider directory with spec/price/health filters
/api/secondary-market	GET · POST	Secondary listings (fixed-price + auction)

The job queue, worker registry, and KV store are in-memory / single-process. On serverless hosts they reset between invocations — see Deployment.

🛠️ Tech Stack

Layer	Stack
Framework	Next.js 16 (App Router · Turbopack) · React 19 · TypeScript
Design	Tailwind CSS v4 · Base-blue design system · framer-motion · 3D tilt / magnetic buttons / confetti / ambient background
Chain	Base (Ethereum L2) · viem · MetaMask · ETH + USDC
Compute	@mlc-ai/web-llm (in-browser GPU inference via WebGPU) · poll-based orchestrator · proof-of-work audits
Fallback AI	OpenRouter — hosted model when no community worker is online
Payouts	viem wallet client signs USDC transfer from a treasury key, with per-wallet daily caps

🚀 Quick Start

# clone
git clone https://github.com/ctrlshifthash/Ram.git
cd Ram/ram-marketplace

# install
npm install

# configure — fill in your keys
cp .env.local.example .env.local

# run
npm run dev          # → http://localhost:3000

Requires Node 18+. An OpenRouter key powers the hosted-fallback RUN. Real worker payouts need a funded Base treasury key (optional — the app runs fine without it, payouts just stay disabled).

🔑 Environment Variables

Copy ram-marketplace/.env.local.example → .env.local (local) or add them in your host's settings (production).

Variable	Scope	Description
OPENROUTER_API_KEY	secret	OpenRouter key — hosted fallback for RUN
NEXT_PUBLIC_TREASURY_ADDRESS	public	Base 0x… wallet that receives rent and pays workers
TREASURY_PRIVATE_KEY	secret	Burner key for that wallet — enables real USDC payouts. Leave blank to keep payouts disabled. Fund with a few $ of USDC + a little ETH for gas.
BASE_RPC_URL	optional	Base RPC (defaults to https://mainnet.base.org)

⚠️ TREASURY_PRIVATE_KEY is a hot wallet on the server — use a burner with small funds only, never your main wallet.

📁 Project Structure

Ram/
├── ram-marketplace/                # the Next.js app (deploy this)
│   ├── app/
│   │   ├── page.tsx                # home — hero, pillars, how it works
│   │   ├── try/                    # free $1 trial — run tasks, no wallet
│   │   ├── marketplace/            # browse + filter nodes
│   │   ├── rent/[id]/              # node detail + rent flow (ETH/USDC)
│   │   ├── earn/                   # browser worker + payouts + task history
│   │   ├── dashboard/              # rentals, metrics, console, worker payouts
│   │   ├── secondary-market/       # buy / auction active leases
│   │   ├── network/                # live protocol stats + activity feed
│   │   ├── docs/                   # full documentation
│   │   └── api/                    # ram · worker · listings · providers · secondary-market
│   ├── components/
│   │   ├── fx/                     # CursorGlow · Tilt · Magnetic · AmbientBg
│   │   ├── BrowserWorker, RamTerminal, RamModule, ProvisionFlow, Reviews …
│   └── lib/
│       ├── walletContext.ts        # MetaMask + Base
│       ├── tokens.ts               # USDC (Base) helpers
│       ├── jobQueue.ts             # orchestrator (register/poll/claim/complete)
│       ├── challenges.ts           # proof-of-work audits
│       ├── payouts.ts              # caps + payout accounting
│       ├── treasury.ts             # viem USDC payouts + signature verify
│       └── store.ts · useStore.ts  # rentals · worker tasks · payouts
└── agent/                          # dedicated provider agent (advanced)

🌐 Deployment

Railway / a long-running Node host (recommended)

The orchestrator, worker registry, and KV store live in memory in a single process, so a persistent Node server keeps live nodes, earnings, and the queue intact.

1. New Project → Deploy from the GitHub repo.
2. Point the service at ram-marketplace (npm install && npm run build && npm start).
3. Add the environment variables.

Vercel

1. Import the repo; set Root Directory → ram-marketplace (it's a subfolder).
2. Add the environment variables.
3. Deploy.

⚠️ Vercel's serverless functions reset memory between requests, so the in-memory worker queue / live registry won't hold. Back them with a shared store (e.g. Upstash Redis) for production, or use Railway.

🗺️ Roadmap

Shipped

• Browser workers — real in-browser GPU compute (WebGPU)
• Orchestrator with live-node registry + hybrid fallback
• Proof-of-work verification (hidden audits, timing floor, slashing)
• ETH & USDC payments on Base via MetaMask
• Real USDC worker payouts + on-chain (Basescan) verification
• Free $1 trial — run tasks with no wallet

Next

• Streaming results — tokens stream back live
• Persistent accounting (database) — earnings & history survive restarts
• Native provider nodes — bigger capacity beyond the browser
• Token buyback-and-burn — route network fees into $RAM

Planned

• On-chain escrow + SLA enforcement with auto-refunds
• Cryptographic proof-of-execution
• On-chain secondary-market auctions · provider reputation · public SDK

❓ FAQ

What chain is this on?

Base (an Ethereum L2). You pay and get paid in ETH or USDC, and connect with MetaMask.

Is the compute real?

Yes — when a worker is online, tasks run on a real model on their GPU via WebGPU. If no worker is live, a managed fallback handles the task so it never fails.

How do workers get paid, and how do I know they earned it?

Per task in USDC, withdrawable on demand to any Base wallet. Nodes must pass hidden proof-of-work audits before they can withdraw, and every payout is an on-chain transaction you can verify on Basescan.

Do I need crypto to try it?

No — the Try page gives every visitor $1 of credit on a shared node, no wallet or signup required.

🔗 Connect

   

_{Idle RAM & GPUs are everywhere. We made them rentable.}