Skip to content
neosource Docs

Platform posture

neosource is built and run as a hosted forge — the way GitHub or GitLab.com are operated. The team’s focus is running it well as a service, and that focus shapes the architecture. It does not come at the cost of openness: every layer sits on open, portable substrates, with no lock-in to any single vendor’s proprietary primitives.

Portable by construction

Section titled “Portable by construction”

The platform is designed to move freely across infrastructure rather than bind to one provider:

  • relational state on Postgres
  • object bytes behind the S3 API — any conforming implementation, not one vendor’s hosted service
  • the content-addressed manifest (operation log, operation heads, object and pack catalogs) behind a storage abstraction, not a single product
  • the event bus on open messaging
  • compute on commodity hardware or any cloud — never a proprietary serverless runtime

No AWS-only, GCP-only, Azure-only, or Cloudflare-only primitive is a hard dependency. The S3 API is a fine thing to build on because many implementations serve it; a specific vendor’s service is never the thing we depend on. The edge is just DNS, TLS, and a reverse proxy — no application logic welded into an edge platform.

Can you self-host it?

Section titled “Can you self-host it?”

No. The platform source is proprietary and is not distributed, so there is no way for a third party to run their own neosource, and we make no self-hosting commitment. neosource is a hosted service.

The client-side tools are the intended exception. The neo CLI — which has the runner agent built into it — is installable today; what has not happened is the source release. It is meant to go out under a permissive licence, so the things you run on your machine need not be a black box, but that is not scheduled.

Then why does portability matter?

Section titled “Then why does portability matter?”

Because the constraint it replaces is vendor lock-in, not installability.

Every tier sits behind an abstraction, and the substrates underneath are open ones we could run on hardware anywhere — object bytes over the S3 API rather than any single vendor’s service, our own compute rather than managed cloud primitives. That keeps us able to move providers, which is a property we want for ourselves. It is not the same thing as being installable by anyone, and it should not be read as a roadmap toward that.

Designing primarily around “what an arbitrary operator can install” tends to pull a forge toward a lowest-common-denominator stack. Building for a platform we operate ourselves lets us pick the right substrate for each workload tier — which is where the engine’s properties come from — while still owing nothing to any one vendor.