How to Pool RAM from Old PCs: The Complete Guide (Yes, It’s Possible for AI)
You can’t merge physical RAM across PCs into one motherboard slot. But you can pool their memory for local AI: open-source software splits a model’s transformer layers across machines over your LAN. Three computers with 16 GB RAM each combine into a 48 GB memory pool (roughly 42 GB usable), running 32B and 70B models that none could load alone.
When hardware forums answer this question, they focus on physical hardware buses. They are technically correct for traditional desktop computing: DDR3 cannot fit into a DDR4 slot, and PCIe buses cannot bridge across separate motherboards over a cable.
However, Artificial Intelligence does not execute like traditional software. Large Language Models (LLMs) calculate sequentially, layer by layer. By distributing those layers across computers on your local network, existing household devices work together as a single unified inference engine.
Why the standard answer is right for gaming (and wrong for AI)
Traditional programs assume Uniform Memory Access. A game engine constantly updates physics, audio buffers, and polygon vertices millions of times per second across shared memory addresses. If a CPU had to wait for an Ethernet packet just to read a single texture byte, frame rates would drop to absolute zero.
Large Language Models execute differently. When you submit a prompt to a 70-billion parameter model:
- The prompt passes into Layer 1, which processes the input tokens.
- Layer 1 outputs an intermediate activation vector (just a numerical array of hidden states, typically 4 KB to 16 KB in size).
- That vector passes into Layer 2, then Layer 3, continuing in a sequential forward pass through all 80 layers.
- Only the final layer evaluates the vocabulary probability to output the next token.
Because each layer only needs the output of the layer before it, the layers do not need to sit on the same physical motherboard. Machine A computes Layers 1–25 in its own RAM, sends a tiny 8 KB vector over your home router to Machine B, and Machine B computes Layers 26–50. Read our technical deep-dive in the How It Works architecture guide.
Can you combine RAM from two computers?
| Computer Setup | Hardware Specifications | Assigned Transformer Layers | Usable AI Memory |
|---|---|---|---|
| Old Laptop | Intel Core i7-7700HQ (16 GB DDR4) | Layers 1 – 22 (CPU/RAM) | 14 GB |
| Home Desktop | AMD Ryzen 5 + GTX 1650 (16 GB DDR4) | Layers 23 – 44 (CPU/GPU) | 14 GB |
| Spare Mini PC / Mac | M-series Mac or Ryzen Mini PC (16 GB) | Layers 45 – 64 (Metal / OpenCL) | 14 GB |
| Total Pooled Cluster | 3 Consumer Computers | All 64 Layers Active | 42 GB Usable (48 GB Total) |
Can DDR3 and DDR4 machines work together?
Because the operating system on each machine manages its own physical memory controller, architecture differences disappear over the network. The main inference process only cares that a worker responds to network RPC calls and reports available allocation capacity. Explore real hardware permutations in our guide: One Cluster, Every Setup: Why RAMDeck Fits Wherever You Start.
How much RAM do I need for a 70B model?
How to pool RAM from old PCs: The open-source DIY steps
Here is the exact step-by-step setup to pool your hardware using pure open-source code:
Step 1: Compile llama.cpp with RPC Enabled
Run these build commands on every computer in your cluster (Windows, macOS, or Linux):
# Clone the official repository
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
# Configure CMake with RPC backend enabled
cmake -B build -DGGML_RPC=ON
# Compile the binaries (add --config Release on Windows)
cmake --build build --config Release -jTip: On Nvidia machines, add -DGGML_CUDA=ON. On Apple Silicon Macs, add -DGGML_METAL=ON.
Step 2: Start the RPC Worker on Each Node
On every worker machine that will donate its RAM to the cluster, launch the RPC listener:
# On Worker 1 (e.g., 192.168.1.101)
./build/bin/rpc-server -H 0.0.0.0 -p 50052
# On Worker 2 (e.g., 192.168.1.102)
./build/bin/rpc-server -H 0.0.0.0 -p 50052Step 3: Launch the Primary Server
On your primary machine, start llama-server with the --rpc flag pointing to your worker IP addresses:
./build/bin/llama-server \
-m models/qwen2.5-32b-instruct-q4_k_m.gguf \
--rpc 192.168.1.101:50052,192.168.1.102:50052 \
--host 0.0.0.0 --port 8080 -c 4096The Engineering Traps of Raw DIY RPC
While raw llama.cpp RPC works, managing a DIY cluster long-term introduces real friction:
- Zombie RPC Processes: If a model switch fails or a service restarts, orphaned
rpc-serverprocesses hold TCP port 50052, causing subsequent connections to fail silently. - Apple Silicon Memory Clamping: macOS limits unified Metal memory allocations to ~70% of total physical RAM. Passing raw capacity causes Metal allocation panics (
GGML_ASSERT). - Proportional Split Bottlenecks: If you pass full capacity for a slow CPU alongside a fast GPU,
llama.cpp‘s default proportional split offloads too many layers to the slow CPU, tanking throughput from 14 tok/s down to 1 tok/s. - Static IPs & Network Drops: If a laptop closes or an IP shifts under DHCP, the server crashes mid-generation.
When should you use a hardware appliance like RAMDeck?
We developed RAMDeck after running into these exact engineering hurdles while scaling internal customer-support AI for TradeMAV. The RAMDeck appliance automates the entire orchestration:
- Zero-Terminal Auto-Discovery: Broadcasts heartbeats across your subnet to discover Mac, Windows, Linux, and Android nodes automatically.
- Dynamic Waterfill Sharding: Maximizes fast GPU offloading first and only routes exact layer spillovers into secondary CPU RAM, eliminating throughput bottlenecks.
- Fault-Tolerant Failover: If a laptop sleeps or disconnects, the coordinator reschedules the missing layers within 3 seconds without dropping your chat session.
- Private OpenAI API: Drop-in compatibility with Open-WebUI, LibreChat, Continue.dev, and LangChain.
Real-world cost comparison: DIY vs. RAMDeck vs. New Hardware
Here is an honest breakdown of the true cost to achieve 40+ GB of local AI memory:
| Approach | Available AI Memory | Can Run 70B Models? | Hardware & Setup Cost |
|---|---|---|---|
| DIY Open-Source (llama.cpp RPC) | 42 GB Usable (3x 16GB PCs) | ✅ Yes | $0 (Manual CLI setup) |
| RAMDeck Turnkey Hub | 42 GB – 140+ GB (Pooled) | ✅ Yes (Full 70B & 120B) | $199 – $299 (Appliance kit) |
| New Nvidia RTX 4090 (24GB) | 24 GB VRAM | ❌ No (Exceeds 24GB ceiling) | $1,800 – $2,200 |
| Apple Mac Studio (M2/M4 64GB) | 64 GB Unified | ✅ Yes | $3,999+ |
| Commercial Cloud (API Subscriptions) | Remote Hosted | ✅ Yes | $240 – $1,200/year (Plus privacy risk) |
What speed can you expect from pooled old PCs?
Tested cluster metrics from our lab benchmarks:
- Qwen 2.5 32B: Clocked at 13.7 tokens per second—comfortably faster than comfortable reading speed (roughly 4–5 words per second).
- 30B MoE (Qwen2.5-Coder): Hit 38–39 tokens per second when pairing a Mini PC with an Apple Silicon Mac mini.
- 120B Parameter Giant (MX-120B): Evaluated across 6 mixed consumer computers (spanning 148 GB pooled RAM) at 1.37 tok/s during a continuous 40-hour stress test.
Read full hardware specs, power draws, and telemetry in: What Speed Looks Like on a Pile of Old Computers.
What happens if a computer disconnects or sleeps mid-run?
Cluster Deep-Dive Guides & Specific Use Cases
Explore dedicated walkthroughs for your exact hardware combination, security requirements, and model sizing:
Private AI for Law Firms & Clinics →
How Harbor & Finch LLP deployed on-premise AI across 3 staff members with 100% data privacy and zero cloud fees.
Running a 120B Model on 6 Old Computers →
Pooling 148 GB RAM across household computers to evaluate massive frontier models locally over LAN.
llama.cpp RPC Multi-Machine Setup →
Exact compilation, daemon flags, and networking commands to link machines using open-source tools.
Running LLMs on 2 PCs Without a GPU →
Dual-machine CPU RAM pooling for laptops and desktops without dedicated graphics cards.
Combining VRAM and System RAM →
How dynamic Waterfill layer sharding prevents slow CPUs from dragging down fast GPU inference.
Local AI Server for Small Business →
Cost breakdown: replace recurring $30/user/mo cloud subscriptions with a one-time pooled office server.
Is llama.cpp RPC Secure? →
Understanding open port 50052, network sniffing risks, firewall rules, and appliance isolation.
Mixing Mac & Windows PCs in One Cluster →
Bridging Apple Silicon Metal GPUs and Windows CUDA/CPU PCs over standard TCP/IP.
How Much RAM to Run Llama 3 70B? →
Memory math for Q4_K_M weights, KV cache sizing, and breaking the 24 GB single-GPU limit.
Can DDR3 and DDR4 PCs Share Memory? →
Why physical motherboard slots reject mismatched DDR generations, but LAN clusters pool them seamlessly.
Frequently Asked Questions
Can you combine RAM from two computers?
Yes, for local AI inference. Software splits model layers sequentially across your local network. A 16 GB laptop and a 16 GB desktop combine into 32 GB of memory, allowing you to load 25 GB to 28 GB models that would crash on either machine alone.
Can DDR3 and DDR4 machines work together?
Yes. Physical memory slots stay on their respective motherboards. Because machines exchange numerical activation tensors over standard Wi-Fi or Ethernet packets, older DDR3 computers, DDR4 rigs, and modern Apple Silicon Macs collaborate seamlessly.
How much RAM do I need for a 70B model?
Approximately 42 GB to 44 GB for a 4-bit quantized model (Q4_K_M) with standard context. Three consumer PCs with 16 GB RAM each provide 48 GB total system RAM (roughly 42 GB usable for AI), providing the headroom required to run 70B models without a $2,000 GPU.
Do you need 10-Gigabit Ethernet to pool RAM for AI?
No. Standard 1-Gigabit Ethernet or Wi-Fi 5/6 works smoothly. The network only transfers intermediate activation tensors (a few kilobytes per token step) between layers, not the entire multi-gigabyte model weights.
Can you mix Windows, Linux, and macOS devices?
Yes. Distributed tensor RPC is operating-system agnostic. Apple Silicon Metal GPUs, Nvidia CUDA cards, and standard x86 CPUs work together in the same homogeneous cluster.
