SpareGrid Compute · pre-launch

Batch compute from the world's idle devices.

SpareGrid Compute is a planned marketplace for interruptible, parallel workloads, run on consumer GPUs and CPUs. It is not a cloud replacement, and this page says where it does not fit.

Network
Not operating
Pilots
Not started
Designs built or tested
0 of 10

Fit checker

Would your workload fit?

Five questions decide most of it. The rules are written out in full, so you can see exactly why an answer comes back the way it does.

Mainstream consumer cards

Data sensitivity
Completion window
Geography

Assessment

Likely fit4 checks. The worst one decides.
  • FitsSplits into small independent tasks and tolerates retries. Models that fit in 16 GB of VRAM or less have the widest pool of devices.
  • FitsThis hardware class is common in consumer devices.
  • FitsThis data can reasonably be processed on devices you do not control.
  • FitsA relaxed completion window leaves room for retries and rescheduling.
Request compute for this workload

Guidance for a conversation, not a quote or a guarantee.

Workload guide

What fits, what might, what does not

Likely fit

5 workloads

Small, independent, restartable tasks on data that is safe to distribute.

  • Batch AI inference

    Run a model over a large queue of inputs where no single answer is urgent.

    Splits into small independent tasks and tolerates retries. Models that fit in 16 GB of VRAM or less have the widest pool of devices.

    Examples

    • Embedding a document corpus
    • Bulk transcription
    • Batch image generation
    • Offline classification
  • Rendering

    Frames or tiles rendered independently and assembled afterwards.

    Each frame is its own task, results are easy to spot-check, and consumer GPUs are what render engines are built for.

    Examples

    • Animation frames
    • Architectural stills
    • Product visualisation
  • Media transcoding

    Convert video or audio between formats and bitrates in segments.

    Segmented jobs are short, deterministic enough to verify, and use encoders every modern GPU and CPU ships with.

    Examples

    • Adaptive-bitrate ladders
    • Archive conversion
  • Simulation and parameter sweeps

    Thousands of independent runs with different seeds or parameters.

    The classic volunteer-computing workload: embarrassingly parallel, restartable, and verifiable by replication.

    Examples

    • Monte Carlo runs
    • Hyperparameter sweeps
    • Scientific batch jobs
  • Data preparation

    CPU-bound processing of non-sensitive data in chunks.

    Chunked work suits ordinary desktops and home servers. The data must be safe to place on devices you do not control.

    Examples

    • Parsing public documents
    • Image resizing
    • Dataset cleaning

Possible, with constraints

3 workloads

Workable only when the constraints in the description hold.

  • Model evaluation and test shards

    Run evaluation suites or test shards in parallel.

    Parallelises well, but the model weights, prompts or source code would sit on contributor devices. Only suitable if those are not confidential.

    Examples

    • Open-model benchmark runs
    • Open-source CI shards
  • Small-model fine-tuning

    Single-GPU fine-tunes that checkpoint often.

    Possible when the job fits one consumer GPU, checkpoints frequently and uses non-sensitive data. A device can leave at any moment.

    Examples

    • LoRA adapters
    • Small vision models
  • Something else

    Tell us what it is.

    The test is simple: can it be cut into small, independent, restartable tasks on data that is safe to distribute?

Not a fit

3 workloads

These belong in a data centre. We would say so rather than take the job.

  • Real-time inference

    Serving users who are waiting for an answer.

    Home devices come and go and sit behind home broadband. We will not offer latency or uptime guarantees on them.

    Examples

    • Chat backends
    • Interactive APIs
  • Large-model training

    Multi-GPU training that needs fast interconnect.

    Needs many GPUs in one room talking over a fast fabric. A scattered network of home machines is the opposite of that.

    Examples

    • Foundation-model training
    • Multi-node distributed training
  • Databases and long-running services

    Anything that must stay up and keep state.

    Contributor devices are interruptible by design. Their owners come first.

    Examples

    • Databases
    • Web services
    • Queues

Positioning

The right tool, and the wrong one

Each kind of supplier is the right answer for some work. We have no benchmarks to publish, so this comparison is qualitative on purpose.

  • Hyperscale clouds

    Best for
    Regulated workloads, guaranteed capacity, managed services, anything with an uptime commitment.
    Trade-off
    You pay for guarantees that batch work may not need.
  • GPU clouds

    Best for
    Training and serving on data-centre GPUs with fast interconnect.
    Trade-off
    Priced for data-centre hardware.
  • Distributed consumer compute

    Best for
    Large queues of small, interruptible, non-sensitive tasks where cost matters more than speed.
    Trade-off
    No uptime or latency guarantees, single-GPU only, and your data sits on hardware you do not control.

Pilots

How a pilot would work

  1. 01

    You describe the workload

    What the job is, how large it is, the data it touches, and the target price per unit of work you would need to beat.

  2. 02

    We assess the fit

    We would check it against the rules on this page, and say no when it is a no. Most of the decision is visible to you before we reply.

  3. 03

    A small pilot

    A first pilot would run on non-sensitive data, at a size you choose, with results you can check yourself.

  4. 04

    Priced per verified unit of work

    Pricing would be per unit of verified work, agreed up front. Not per hour a device claims to have spent.

Pilots have not started. No workload has run on SpareGrid. Everything above describes how a first pilot is designed to work.

Have a queue of work that fits?

Tell us about it. We read every request, and we will tell you if it is not a fit.

Request compute