Next-Generation Serverless

Golem is the first serverless computing platform with software-defined reliability, letting you build reliable distributed systems with simple code.

How it works

1. Worker Template

The building blocks of your Golem application are worker templates. Worker templates represent a component of your overall application that has been compiled to WebAssembly. Worker templates have a public API (defined using WIT, an alternative to Protobuf), your business logic, and the rest of your code, including whatever frameworks and libraries you use.

2. Workers

Golem uses worker templates to create workers, which are running instances of your templates. Workers are isolated from each other and different workers from different versions of the same worker template may execute concurrently without issue. Golem allows you to use one worker for each incoming request, or you can use the same worker to handle related requests.

3. Isolation

Workers execute independently from one another. Failures in one worker (even catastrophic ones, such as out of memory) have no effect on other workers. Deploying new versions of a worker template only affects new workers created from the template. Older workers created with earlier templates continue to run unaffected by the updated worker template.

4. Replication

If you execute your worker directly, then it interacts directly with your operating system, and if your machine dies, your worker dies. But when you execute on Golem, then Golem records all your worker’s interactions with the outside world. This log of host interaction (oplog) can be used for recovery in the event of a failure that requires the worker to be relocated to a healthy node.

5. Resiliency

Because Golem proxies all host interactions, it is able to identify failed interactions that may be recoverable. For example, HTTP requests, gRPC calls, and database queries. Golem automatically retries recoverable interactions with third-party cloud services, databases, and microservices, using sophisticated and user-configurable retry policies.

6. Supervision

Golem actively supervises executing workers. In the event of a failure, such as the node a worker is executing on is restarted or goes down, Golem relocates the worker to a new node. Golem uses the oplog to restart the worker, and play back all host interactions, thus fully restoring the complete state of the worker to the moment before the failure event occurred.

How it works

01
Components

The building blocks of your Golem application are components. Components represent a part of your overall application that has been compiled to one or more WASM components. Components have a public API (defined using WIT, a Protobuf alternative), your business logic, and the rest of your code, including whatever frameworks and libraries you use.

02
Workers

Golem uses components to create workers, which are running instances of your components. Workers have a unique identity, which you can specify or let Golem randomly generate. Golem allows you to use new workers for each incoming request, or you can use the same worker to handle related requests over an indefinite period of time.

03
Isolation

Workers execute independently from one another. Even catastrophic failures in one worker, such as out of memory, have no effect on other workers. Deploying new versions of a worker component only affects new workers created from the component. Older workers created with earlier versions continue to run unaffected.

04
Replication

Because Golem has a custom executor for WASM components, it behaves differently than direct execution. When you deploy on Golem, Golem records all your worker’s interactions with the outside world into an operation log (oplog). The oplog can be used for automatic observability, including tracing and profiling, and Golem uses it for fault-tolerance.

05
Resiliency

Because Golem proxies all host interactions, it is able to identify failed interactions that may be recoverable. For example, HTTP requests, gRPC calls, and database queries. Golem automatically retries recoverable interactions with third-party cloud services, databases, and microservices, using sophisticated and user-configurable retry policies.

06
Robustness

Golem actively supervises executing workers. In the event of a fault, such as the node that a worker is executing on is restarted or downed, Golem relocates the worker to a new node. Golem restarts the worker and uses the oplog or a memory snapshot to fully restore the state of the worker to the moment before the fault, providing transparent fault-tolerance.

How it works

1

Build Your Backend

Write your backend in any programming language that can target server-side WebAssembly (WASM), which includes C/C++, Rust, Go, Python, Javascript, and others. Because Golem Cloud is serverless, you need only define worker templates, which can process incoming requests and produce outgoing responses.

2

Define Your API

Using our Management Console, CLI, or REST API, you can define what your API should look like and how every endpoint should map to code that you have implemented in your backend. You can choose to map each endpoint to a new worker, or use long-lived workers to statefully handle endpoints.

3

Deploy Your API

Using our Management Console, CLI, or REST API, deploy your API to any subdomain of your choosing. Your versioned and automatically validated API will support encryption, CORS, caching, request logging, and other features without you having to write any code or manage any infrastructure.

4

Automatic Scalability

Golem will automatically scale up infrastructure in order to satisfy any load on your API. If you have mapped each endpoint to a new worker, then you have effectively infinite scalability. If you use long-lived workers to handle some endpoints, you can specify caching settings to handle high traffic.

5

Automatic Robustness

Golem Cloud supervises each worker and performs continuous incremental snapshotting. If any of your workers are interrupted due to restarts, updates, or infrastructure failures, Golem Cloud restores and resumes the workers on new nodes, ensuring your business logic executes to completion every time.

6

Operate Joyfully

Connect to running workers to see their status and output, or use our control panel with dashboard to monitor and manage running workers. Test long-running workers for compatibility with hot updates and switch-on features like automatic retries, logging, and telemetry (Coming Soon).

Workflows

Durable execution ensures that complex, multi-step workflows are executed reliably, even in the face of system failures or restarts. With Golem, workflows involving multiple services and tasks continue seamlessly, maintaining state and progress without manual intervention. This feature is crucial for workflows that require long-running processes or depend on the completion of preceding steps, making Golem ideal for automating and streamlining intricate workflows with guaranteed execution integrity.

Business Processes

In managing business processes, durability is key to ensuring consistent and uninterrupted operations. Golem's durable execution allows businesses to implement processes that remain active and consistent, unaffected by system disruptions or downtimes. This robustness is particularly beneficial for critical business operations like order processing, inventory management, and customer relationship activities, where reliability directly impacts customer satisfaction and business continuity.

Infrastructure Orchestration.

Infrastructure orchestration involves coordinating various IT resources and services. Golem's durable execution ensures that orchestration tasks are resilient to failures. This is vital when managing complex deployments, scaling operations, and performing system updates. By leveraging Golem, IT teams can confidently orchestrate their infrastructure, knowing that each component will maintain its state and functionality, even in unpredictable cloud environments.

Business Transactions

Business transactions often require high levels of reliability and atomicity. Golem's approach to durable execution ensures that transactions are executed to completion, maintaining data integrity and consistency, even in the event of failures. This reliability is crucial for financial operations, e-commerce transactions, and any other scenario where transactional integrity is a must, reducing the risk of data corruption or loss.

AI & ML

In advanced AI applications, particularly with complex models like LLMs, execution often involves multi-step processes or iterative refinements. Golem's durable execution ensures the continuity and reliability of these long-running and computationally intensive tasks. This capability is essential for AI models requiring iterative feedback and adjustment, guaranteeing that each computational step is completed without disruption. The practical benefits include uninterrupted iterative processes, efficiency in long-running tasks, and scalability for expanding AI operations. Golem's robust framework is particularly valuable for embedding AI into applications, providing the resilience needed to handle the complexities of advanced models like LLMs efficiently.

ETL

ETL processes are critical for data management and analytics, often involving large datasets and complex transformations, which can take a long period of time to complete. Golem's durable execution guarantees the resilience of ETL pipelines, ensuring data integrity and process completion, even if system disruptions occur. This is especially important for businesses relying on timely and accurate data processing for analytics and decision-making.

Streaming Analytics

Streaming analytics involves analyzing data in real-time as it flows through systems. With Golem's durable execution, these analytics processes become more reliable, ensuring continuous data processing and analysis, even in the face of network instability or hardware failures. This ensures that real-time insights are consistently delivered, crucial for scenarios like fraud detection, real-time marketing, and operational monitoring.

Features

Transactional Logic

Golem’s durable execution technology ensures that your logic executes flawlessly, even in the presence of faults, software updates, and cloud flakiness. Focus on business logic, without having to consider complex failure scenarios.

Transparent Durability

Your services automatically execute with maximum, fine-grained durability, no matter which language or technology stack you choose. Enjoy the full benefits of durable computing without having to manually denote ‘activities’.

Durable State

With Golem’s durable execution technology, in-memory data structures like arrays and maps become as durable as database tables. Use fewer databases, caches, and queues, without compromising strong ACID guarantees.

Full Isolation

Golem fully isolates and sandboxes code at the level of each request, so errors in the processing of one request have no effect on the processing of other requests. It’s the gold standard of isolation, for a new generation of bulletproof.

Error Recovery

Golem’s intelligent and automatic error recovery helps protect you from the instability inherent in using networked cloud services, like databases and APIs. Embedding manual retries in your application logic is a thing of the past.

Polyglot

Use any programming language or technology stack. Thanks to the WASM component model supported by Golem, you can even use multiple programming languages in building your application, all of which interact in a type-safe way.

Cloud-neutral

By supporting the WASM component model, Golem lets you separate your requirements (such as storage) from your cloud provider. Ditch lock-in and swap your provider, or run on your own cloud.

Open Source

Golem is fully open source, brought to you by a team with a proven track record of delivering Enterprise-grade solutions for developer infrastructure. Build on open infrastructure that will thrive for decades.

Open Standards

All standards supported by Golem, including formats and specifications, are open. From WIT to WASM to WASI, and everything in between, Golem is built on an open standard that eliminates vendor lock-in.

Secure by Default

Golem Cloud gives you complete sandboxed and independent execution of all workers, relying on WebAssembly’s powerful security model. In addition, Golem Cloud lets you lock down who can invoke which functions on which instances.

Pricing

preview plan

Free
10 active workers
10,000 inactive workers
10 MB / worker
Transient lifetime
get started

developer plan

Free
10 active workers
10,000 inactive workers
10 MB / worker
30 days lifetime
coming soon

production plan

TBD / monthly
active workers
inactive workers
MB / worker
days lifespan
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
coming soon

Subscribe to the Golem Open Source Newsletter

Subscribe to the Golem Open Source Newsletter to learn about improvements to Golem, and to hear about the latest articles, talks, and conferences that show you how to build reliable applications using Golem.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.