G-push

G-push is “crowdfunding for computing power,” pooling unused CPU/GPU time to safely split, run, verify, and reward distributed workloads across PCs.

Comment

Inspiration

Many computers spend a large part of the day with unused CPU and GPU capacity.

Crowdfunding showed me that a large goal can be achieved when many people contribute a small amount. I wanted to apply the same idea to computing: instead of contributing money, people contribute unused computing time.

That idea became G-push — “crowdfunding for computing power.”

The goal is to connect spare computing resources from multiple PCs and make them available to people who need more computation, without requiring them to own expensive hardware.

Blender rendering is the first practical workload, but G-push is designed as a more general distributed computing platform.

What it does

A user creates a Project and uploads a workload. For the current prototype, this is a Blender .blend file.

G-push then:

  1. inspects the input,
  2. divides the work into smaller Work Units,
  3. assigns those units to available Worker PCs,
  4. executes them in a restricted environment,
  5. collects the results,
  6. verifies them with a separate Trusted Verifier, and
  7. records a Contribution only for accepted work.

This creates a system where computation can be shared between multiple computers while still keeping track of who performed the work and whether the returned result is valid.

How I built it

I built G-push as a Windows desktop application connected to a distributed backend.

The main flow is:

Project → Job → Work Units → Workers → Result Upload → Trusted Verifier → Contribution

For the Blender prototype, a Project is divided into multiple rendering units that can be processed independently on different machines.

I also built several safety mechanisms because sending another person's file to a remote computer is very different from running your own file locally.

These include:

  • deterministic inspection of Blender files before execution,
  • restricting which Workers are allowed to execute a Project,
  • isolated execution using Windows sandboxing / AppContainer,
  • network restrictions,
  • child-process restrictions,
  • bounded CPU, memory and execution time,
  • leases so unfinished work can be reassigned,
  • SHA-256 based integrity checks,
  • and a separate Trusted Verifier that checks returned results before a Contribution is accepted.

I tested the system using multiple physical Windows PCs. In one test, a Blender workload was divided into 12 Work Units, processed by another machine, uploaded, verified, and recorded as Contributions.

Challenges

The hardest part was not simply distributing the computation.

The difficult question was:

How can I safely run someone else's workload on another person's computer and still trust the returned result?

During development, I encountered problems such as sandbox permissions preventing Blender from starting, files that worked normally but failed inside a restricted environment, temporary verification failures, Worker recovery, and maintaining the relationship between the original input, the Worker, and the returned result.

Another challenge was making failures recoverable.

If a Worker disappears, a Work Unit should not remain permanently stuck. G-push therefore uses leases and reassignment so unfinished work can be returned to the available pool.

I also learned that distributed computing is not only about performance. Identity, integrity, failure recovery, isolation, and verification are just as important.

What I learned

Through G-push, I learned about:

  • distributed systems,
  • job scheduling,
  • fault recovery,
  • sandboxed execution,
  • Windows security boundaries,
  • file integrity verification,
  • distributed state management,
  • desktop application development,
  • backend infrastructure,
  • and designing systems that fail safely.

I also learned how difficult it is to turn a prototype that works on one computer into a system that can safely operate across different physical machines.

What's next

Blender is only the first workload.

In the future, I want G-push to support other types of computation such as scientific computing, image processing, simulation, and AI-related workloads.

My long-term goal is to make unused computing power something that can be shared safely, just like people share funding, storage, or bandwidth today.

Instead of buying more hardware for every large computation, G-push aims to connect computing power that already exists.

Built With

Share this project:

Updates

Submission history