Resonate

— an implementation

Try it

Resonate brings

reliability and scalability

to the language you love

Currently available in

Ephemeral to Durable Invocation | Run here

# Ephemeral to Durable
# Invoke foo() here
def main():
    resonate.run(foo, promise_id, args)

Ephemeral to Durable Invocation | Run over there

# Ephemeral to Durable
# Invoke foo() over there
def main():
    resonate.options(target="group-b").rpc("foo", promise_id, args)

Durable to Durable Local Function Invocation | Run here

# Durable to Durable
# Run bar() here
@resonate.register
def foo(ctx, args):
    promise = yield ctx.lfi(bar, args)
    result = yield promise
    return result

Durable to Durable Remote Function Invocation | Run over there

# Durable to Durable
# Run bar() over there
@resonate.register
def foo(ctx, args):
    promise = yield ctx.rfi("bar", args).options(
        target="group-b"
    )
    result = yield promise
    return result

Durable to Durable Detached Function Invocation | Run detached

# Durable to Durable
# Run bar() detached
@resonate.register
def foo(ctx, args):
    yield ctx.detached("bar", args).options(
        target="group-b"
    )
    return

Run here

Run over there

Sequential code

Concurrent, distributed, and durable executions

Resonate is dead simple, formally verified, and deterministically tested

— the way all software should be.