Introducing Distlang

Distributed systems have become the default way we build software.
But the way we program them has not changed much.

Most modern systems are still assembled manually from queues, services, databases, retries, and observability tooling. Microservices helped break applications into smaller components, but they did not fundamentally change the abstraction level of distributed programming.

If you’re curious about the philosophy behind this project, you can read more in Initial Inspiration for Distlang. This post explains the first step toward that vision.

A shift toward serverless systems

Over the last decade, serverless platforms have quietly changed how applications scale.Instead of provisioning servers and orchestrating services, developers can deploy small pieces of logic that run on demand. The platform handles replication, scaling, and resource allocation automatically.

This model has a few powerful properties:

  • compute scales with demand
  • idle resources disappear
  • deployment units become smaller and more focused
  • infrastructure concerns move into the platform

Serverless systems begin to resemble a runtime environment rather than traditional infrastructure. However, serverless platforms introduced a new problem. Each cloud provider created its own runtime model, APIs, and deployment mechanisms. Applications written for one platform are rarely portable to another.

The first step: portable distributed applications

Distlang starts with a simple goal. Write applications once and deploy them across multiple serverless platforms. Instead of writing directly against vendor-specific APIs, applications target a common runtime model. A build step then compiles that application into the appropriate deployment artifacts for each platform.

The early versions of Distlang focus on supporting platforms such as:

  • Cloudflare Workers
  • AWS Lambda
  • other serverless runtimes over time

The idea is straightforward:

Application -> Distlang build -> Cloudflare / AWS / other runtimes

In this model, infrastructure becomes a deployment target, not something the application is tightly coupled to.

Where this is going

Portable deployment is only the first step.

The larger goal is to explore whether distributed systems themselves can be expressed at a higher level of abstraction — similar to how programming languages abstracted away machine instructions decades ago. That broader motivation is explained in more detail in Initial Inspiration for Distlang:

Over the coming weeks we will publish:

  • a simple example application
  • the structure of the Distlang runtime
  • how the build system targets multiple serverless platforms
  • early experiments with distributed primitives

Participate in the project

Distlang is an early experiment, and the direction of the project will evolve through discussion and collaboration.

If the ideas in this post resonate with you, we would love to hear your thoughts — whether it’s about runtime design, distributed primitives, or how a language like this could fit into real-world systems.

You can follow the development and contribute ideas here: https://github.com/distlanglabs/distlang

Issues, discussions, and design ideas are all welcome. The goal of this project is to explore new abstractions for distributed systems together.