u/Successful_Option_77

I’ve probably listened to every episode, and I’ve spent years thinking about how to solve the problems we have on the web.

After working on a peer-to-peer compute network idea for the last three years, I think I’ve finally found the core issue:

We give systems too much access by default, then spend the rest of our time trying to claw that access back with permissions, firewalls, TLS, access control, routing rules, configuration layers, and increasingly fragile infrastructure.

Each layer creates new problems.

TLS creates routing complexity.
Routing creates configuration complexity.
Configuration complexity creates lazy admin shortcuts.
Lazy admin shortcuts create security failures.

My core realization is simple:

We need identity-based routing.

Your identity should be your public key. Any data meant for you should be sealed directly to you as the recipient.

That changes the whole model.

If the message content is already encrypted to the recipient, we no longer need to care as much if the message is captured, stored, routed through the wrong machine, or temporarily handled by an untrusted relay. The relay can move the packet, but it cannot read it.

The missing piece is incentives.

Nobody wants to relay traffic for free forever. But it should be possible to account for relay work without revealing message contents. In the simplest form:

I relay your messages.
You relay mine.
The network can prove useful work happened without exposing private data.

From there, the model becomes much more powerful.

Your device has an identity.
Your apps have identities.
Your data is sealed to the identities that are allowed to access it.
Even in failure cases, the blast radius becomes much smaller.

Instead of trusting platforms, cloud providers, app stores, and tech giants with everything by default, we could join our devices into a global overlay network where identity, routing, compute, and data ownership are built from the ground up around cryptographic control.

The goal is apps that can run anywhere, on any platform, while the user remains the guardian of their identity and data.

I know this sounds naive. I know it sounds too broad. But I’ve been building toward this for years.

The repo is here:
https://github.com/Sylchi/edgerun-c

The long-term goal is simple:

A world where people can run software freely, communicate privately, share compute voluntarily, and stop giving 30% of their digital lives to tech giants just because the current web architecture made that the default.

I’m releasing my work earlier than I originally wanted.

It is unfinished. Some parts are rough. Some things are experimental. Some pieces are probably going to change. But I do not have enough Codex credits to keep pushing it forward at the speed I want, and I think the idea is important enough that it should exist in public instead of sitting on my machine.

The project is called EdgeRun.

The basic idea is simple: people already own a lot of unused compute. Laptops, desktops, phones, home servers, small clusters, GPUs, storage, network bandwidth. Most of it sits idle. At the same time, useful research, AI workloads, medical computation, personal data processing, and decentralized services need more compute.

I want to build a system where people can voluntarily contribute their unused resources, earn from them, and still keep control of their own machines and data.

The long-term goal is not just “another cloud provider.” The goal is personal infrastructure.

I believe people should be able to own their digital life again.

Right now, most people’s data is scattered across big companies. Photos in one place, documents in another, messages somewhere else, health data locked behind another app, financial data somewhere else again. Then people rent access to AI systems that barely know them, because their real context is trapped across platforms.

I want a future where you can import your own data, keep it under your control, run local or permissioned AI over it, and decide what gets shared, rented, encrypted, computed, or deleted.

EdgeRun is my attempt at building the foundation for that.

The philosophy is:

Your computer should work for you first.

Your data should belong to you.

Compute should be useful even when it is idle.

Networks should be verifiable instead of based only on trust.

Small machines should be able to cooperate like a larger system.

People should be able to earn from infrastructure they already own.

Medical research and public-good computation should not be limited only to giant companies and universities.

A lot of the work is around verifiable execution, signed events, deterministic messages, content-addressed storage, node identity, routing, relay nodes, and eventually economic incentives. The point is to make it possible for machines to do useful work for each other while leaving a cryptographic trail of what happened.

I am not claiming it is finished.

I am not claiming it is production-ready.

I am not claiming I have solved every hard problem.

What I am saying is that the direction feels right.

The internet became too centralized. Personal computing became rented access to someone else’s platform. AI is making that worse unless people also get tools to own their own context and compute. I want to build something that moves in the opposite direction: local-first, verifiable, user-owned, privacy-respecting, and useful.

I am releasing the work so others can inspect it, criticize it, build on it, or tell me where I am wrong.

Even if the current implementation is imperfect, I think the idea is worth putting out there.

If you care about decentralized compute, personal clouds, local AI, privacy, verifiable systems, or using idle hardware for something more useful than sitting there doing nothing, I would appreciate feedback.

The repo is here: https://github.com/edgerun-tech/edgerun

Currently working on packing all functionality into pocketbase format, my testing showed 31mb pocketbase when extracted, i think my version with built in dns, dhcp, http1,2,3, acme, tls, crypto, built in compositor and ui, oci runtime and much more will stay under 10mb.