Private LLM hosting vs Salad (SaladCloud)
We rent DGX Sparks, so weigh that against everything below, and it's worth being direct about what Salad actually is. Salad, marketed as SaladCloud, is a distributed compute marketplace built on idle consumer hardware: individual gamers and PC owners opt in to run jobs on their own machines for payment, coordinated by Salad's platform rather than run in a data center Salad itself operates. That's a genuinely different trust and reliability model from a dedicated enterprise machine, not a minor detail. GPUwerk is the other end of that spectrum: one company operating its own enterprise-grade DGX Spark fleet in a data center it controls.
Side by side
| Salad (SaladCloud) | Dedicated DGX Spark (GPUwerk) | |
|---|---|---|
| What it is | A distributed marketplace running jobs on idle consumer PCs (largely gaming rigs) whose owners opt in for payment; Salad coordinates the network but doesn't own the hardware. | A single-purpose GPU host: one dedicated DGX Spark, owned and operated by GPUwerk, rented by the hour. |
| Who operates the hardware you land on | An individual consumer PC owner, not a data center operator; the machine is their personal computer, run under whatever conditions they happen to have it in. | GPUwerk directly. The company you're paying is the company running the machine, in a purpose-built data center. |
| Hardware class | Consumer GPUs in gaming PCs, not enterprise or data-center-grade hardware; specs and condition vary node to node. | Enterprise DGX Spark hardware, 128GB unified memory, identical specification across the fleet. |
| Reliability model | Interruptible by design: a job can be reassigned or lost if a node's owner turns off their PC or loses connectivity, which is why Salad is positioned for fault-tolerant, batch-style workloads. | A dedicated machine that stays yours for the duration of your reservation, running in a data center built for continuous uptime. |
| Region | Wherever the participating consumer node happens to be, not a controlled data center location. | EU-Central (Prague), exclusively. One controlled location, no dependence on where a volunteer's PC sits. |
| Who can see your data | Governed by Salad's platform terms, running on hardware physically in the possession of an individual consumer whose setup Salad doesn't fully control; worth reading Salad's current terms closely for a private workload. | Nobody at GPUwerk. Our DPA states GPUwerk "hosts the machine but does not access, read, copy, index, or analyse the content of the controller's instance." |
| Pricing model | Positioned around low cost for interruptible workloads, priced per GPU tier; check Salad's current pricing page for live rates. | Per hour, billed per minute: $0.79/hour on-demand, $0.59/hour for a customer-requested stop that holds your reservation. One rate regardless of workload, per pricing. |
| Contracts and DPA | Salad's own platform terms; review their current published documents for what's covered for a production or private workload. | A standard GDPR Article 28 DPA published free at /legal/dpa, no negotiation required. Sub-processor list at /legal/sub-processors states none are engaged for instance workloads. |
The worked cost example
Take a private inference workload that needs to be available continuously across a full month, the kind of workload where an interruption matters. Two ways to serve it:
Salad. Priced per GPU tier on a network built for interruptible, fault-tolerant batch jobs; the current rates are on Salad's own pricing page and GPUwerk didn't invent a blended figure here. Salad's low prices reflect that the underlying hardware is consumer-owned and the job can be interrupted, which is a reasonable trade for the right workload but a poor fit for continuous private hosting where interruptions aren't acceptable.
Dedicated Spark. At $0.79/hour, running continuously for a 730-hour month costs 730 × $0.79 = $576.70, flat, on hardware that doesn't disappear because someone turned off their PC. If you hold the reservation instead of running it, the held rate drops that to 730 × $0.59 = $430.70.
For batch jobs that tolerate interruption and want the lowest possible price, Salad's model is a legitimate, honest trade of reliability for cost. For a private LLM endpoint a business depends on, that trade generally doesn't make sense.
Migration path
Salad workloads are typically containerized jobs designed to tolerate interruption and reassignment, which is a different application design than a long-running service. Moving to a Spark means deploying a normal always-on service: serve a model through vLLM, which exposes an OpenAI-compatible endpoint, and put LiteLLM in front for request logging and key management. Expect to simplify your retry and checkpointing logic once the underlying machine is no longer expected to disappear mid-job.
When Salad is the right choice
- Your workload is batch-style, stateless, and tolerant of interruption or reassignment.
- Lowest possible price matters more than a guaranteed, consistent machine.
- You're not hosting a private, continuously available inference endpoint a business depends on.
When a dedicated Spark is the right choice
- You're hosting a private LLM endpoint that needs to stay up and can't tolerate an unannounced interruption.
- Enterprise-grade, data-center hardware matters more than the lowest possible headline price.
- EU data residency and a standard GDPR DPA are requirements a consumer-hardware marketplace isn't built to offer.
FAQ
Is Salad (SaladCloud) a good alternative to GPUwerk for LLM hosting?
Salad, also known as SaladCloud, is a distributed compute marketplace built on idle consumer hardware: individual gamers and PC owners opt in to run jobs on their own machines in exchange for payment, coordinated by Salad's platform. That's a materially different trust and reliability model from a dedicated enterprise data center, since the underlying hardware is consumer-grade, privately owned, and not purpose-built for continuous production workloads. GPUwerk operates its own DGX Spark fleet in a data center it controls, with enterprise-grade hardware and one accountable operator. Salad's model suits price-sensitive, fault-tolerant batch work; GPUwerk's model suits a private LLM workload that needs a known, consistent, EU-based machine.
What's the difference between a DGX Spark and a Salad node?
A Salad node is a consumer PC, typically a gaming rig, owned and run by an individual who opted into Salad's network; specs, uptime, and location vary node to node and a job can be interrupted if the owner's machine goes offline. A DGX Spark is a standard enterprise machine GPUwerk operates directly: 128GB unified memory, NVIDIA's DGX Spark architecture, the same specification on every node in EU-Central, running in a data center built for continuous uptime rather than someone's home.
Is a DGX Spark cheaper than Salad?
Salad markets itself around low prices for interruptible, fault-tolerant workloads, and its current rates are on Salad's own pricing page; GPUwerk didn't invent a blended figure here since node pricing on Salad varies by GPU tier and availability. A dedicated Spark costs $0.79/hour flat, one known number for one dedicated enterprise machine with no interruption risk. Compare Salad's rate for a similar GPU tier against that flat number, but weigh it against the reliability and data-handling difference between a home PC and a managed data center.
Why choose a DGX Spark over Salad?
Mainly reliability, data handling, and hardware provenance for a private, continuous workload. A Spark runs on enterprise hardware in a data center GPUwerk controls in Prague, under one standard DPA, with no risk of a node going offline because its owner turned off their PC. Salad's consumer-hardware model is well suited to interruptible batch jobs where price matters more than a guaranteed, known machine; for private LLM hosting where consistency and EU data residency matter, a Spark is the better fit.
GPUwerk did not find a single Salad price representative of every GPU tier and availability window; check Salad's own pricing page. GPUwerk's own figures ($0.79/hour, $0.59/hour, $576.70/month) come from our published pricing.