Build with confidence.confidence.Resonate.

Complex problems. Simple code.

No more duct-taping queues, schedulers, and state stores.

Resonate replaces brittle integrations with a single, developer-friendly model for distributed execution —

Turning the hardest parts of distributed systems into a few lines of code.

So you can focus on features, not firefighting.

Get started with Resonate

Async/Await for your entire application.

A simple programming model that works across failures, scales seamlessly, and feels native to your language.

From service orchestration, to transactional applications, to autonomous systems —

Resonate empowers developers to confidently build reliable and scalable cloud applications.

Dead simple durable execution.

Resonate is dead simple, formally verified, and deterministically tested —

Enabling developers to reliably scale applications limitlessly,

With distributed, durable, and composable functions.

Open source software you can trust.

Resonate is fully transparent, community-driven, and ready for contributions.

Resonate implements the open Distributed Async Await specification —

A procedural async/await programming model that works across distributed processes.

Made possible by the open Async RPC protocol —

Which enables platform-level service discovery, load balancing, and crash recovery.

Resonate's API surface

Resonate offers a practical and holistic programming model —

That brings reliability and scalability to the language you love .

Resonate is currently available in

Python and TypeScript.

Call functions locally (same process), remotely (across processes),

Synchronously (blocking), asynchronously (non-blocking),

From the ephemeral world (doesn't resume after recovery),

Or from the durable world (resumes after recovery).

resonate.run()

Local, synchronous, ephemeral to durable invocation.

# foo() and bar() are in the same process
# bar() is registered with Resonate
@resonate.register
def bar(ctx: Context, arg: str):
  # ...
  return result

# Example of a local (same process) synchronous (blocking) call
# From ephemeral (does not resume after recovery) function foo()
# To durable (resumes after recovery) function bar()
def foo():
  try:
    result = bar.run("write_once_id", arg="hello world")
    # ...
  except Exception as e:
    # ...

resonate.begin_run()

Local, asynchronous, ephemeral to durable invocation.

# foo() and bar() are in the same process
# bar() is registered with Resonate
@resonate.register
def bar(ctx: Context, arg: str):
  # ...
  return result

# Example of a local (same process) asynchronous (non-blocking) call
# From ephemeral (does not resume after recovery) function foo()
# To durable (resumes after recovery) function bar()
def foo():
  try:
    handle = bar.begin_run("write_once_id", arg="hello world")
    result = handle.result()
  except Exception as e:
    # ...

resonate.rpc()

Remote, synchronous, ephemeral to durable invocation.

# bar() is in process-group-b
# bar() is registered with Resonate
@resonate.register
def bar(ctx: Context, arg: str):
  # ...
  return result

# foo() is in process-group-a
# Example of a remote (different process) synchronous (blocking) call
# From ephemeral (does not resume after recovery) function foo()
# To durable (resumes after recovery) function bar()
def foo():
  try:
    result = resonate.options(target="process-group-b").rpc(
      "write_once_id", func="bar", arg="hello world"
    )
  except Exception as e:
      # ...

resonate.begin_rpc()

Remote, asynchronous, ephemeral to durable invocation.

# bar() is in process-group-b
# bar() is registered with Resonate
@resonate.register
def bar(ctx: Context, arg: str):
  # ...
  return result

# foo() is in process-group-a
# Example of a remote (different process) asynchronous (non-blocking) call
# From ephemeral (does not resume after recovery) function foo()
# To durable (resumes after recovery) function bar()
def foo():
  try:
    handle = resonate.options(target="process-group-b").begin_rpc(
      "write_once_id", func="bar", arg="hello world"
    )
    result = handle.result()
  except Exception as e:
    # ...

context.run()

Local, synchronous, durable to durable invocation.

# bar() and baz() are in the same process
def baz(ctx: Context, arg: str):
  # ...
  return result

# bar() is registered with Resonate
# Example of a local (same process) synchronous (blocking) call
# From durable (resumes after recovery) function bar()
# To durable (resumes after recovery) function baz()
@resonate.register
def bar(ctx: Context, arg: str):
  result = yield ctx.run(func=baz, arg=arg)
  return result

context.begin_run()

Local, asynchronous, durable to durable invocation.

# bar() and baz() are in the same process
def baz(ctx: Context, arg: str):
  # ...
  return result


# bar() is registered with Resonate
# Example of a local (same process) asynchronous (non-blocking) call
# From durable (resumes after recovery) function bar()
# To durable (resumes after recovery) function baz()
@resonate.register
def bar(ctx: Context, arg: str):
  promise = yield ctx.begin_run(func=baz, arg=arg)
  result = yield promise
  return result

context.rpc()

Remote, synchronous, durable to durable invocation.

# baz() is in process-group-c
# baz() is registered with Resonate
@resonate.register
def baz(ctx: Context, arg: str):
  # ...
  return result

# bar() is in process-group-b
# bar() is also registered with Resonate
# Example of a remote (different process) synchronous (blocking) call
# From durable (resumes after recovery) function bar()
# To durable (resumes after recovery) function baz()
@resonate.register
def bar(ctx: Context, arg: str):
  result = yield ctx.rpc(func="baz", arg=arg).options(
    target="process-group-c"
  )
  return result

context.begin_rpc()

Remote, asynchronous, durable to durable invocation.

# baz() is in process-group-c
# baz() is registered with Resonate
@resonate.register
def baz(ctx: Context, arg: str):
  # ...
  return result

# bar() is in process-group-b
# bar() is also registered with Resonate
# Example of a remote (different process) asynchronous (non-blocking) call
# From durable (resumes after recovery) function bar()
# To durable (resumes after recovery) function baz()
@resonate.register
def bar(ctx: Context, arg: str):
  promise = yield ctx.begin_rpc(func="baz", arg=arg).options(
    target="process-group-c"
  )
  result = yield promise
  return result