Reboot | React's bullet-proof backend

FAQ

Docs

Cloud Login ›

FAQ

Docs

Cloud Login ›

React apps, meet your

bullet-proof backend

Reboot is a framework for building reactive backends out of durable data structures that safely compose into scalable distributed systems.

With Reboot, you just write code. No more duct-taping your apps together with databases, caches, queues...

Build full stack apps with

that are realtime, transactional, and fault-tolerant.

Realtime

Reboot apps are reactive by default. Anytime state changes on the backend, your React frontend updates automatically. Multiplayer out-of-the-box, no polling necessary!

Frontendrebank/web/App.tsx

 
// Lookup durable types by ID.
 
const account = useAccount({ id: myAccountId });
 

 
// Use generated React hooks to get updates from
 
// the backend _reactively_.
1
const { response } = account.useBalance();
 

 
...

Reboot generates type safe React custom hooks that sync updates from the backend.

Backendrebank/backend/account_servicer.ts

 
class AccountServicer extends Account.Servicer {
 
  // Mutators update `state` directly, which gets durably
 
  // persisted when the function returns.
 
  async deposit(context, state, request) {
2
    state.balance += request.amount;
 
    return {};
 
  }
 

 
  async balance(context, state, request) {
3
    return state.balance;
 
  }
 

 
  ...

Any time backend state changes (e.g., someone calls Account.deposit)...

... all reader functions, whether reactively called from the frontend or the backend, re-execute and return the latest results.

Fault-tolerant

Faults are inevitable. Reboot makes it easy to call functions at least once, at most once, or exactly once. Just call your functions and let Reboot take care of the rest!

Frontendrebank/web/App.tsx

 
const payee = useAccount({ id: payeeAccountId });
 

 
// Will retry safely for retryable errors,
 
// e.g., network disconnects.
1
await payee.deposit({
 
  amount,
 
});
 

 
...

You don't have to worry about safely retrying mutations from the frontend, Reboot will retry for you ...

Backendrebank/backend/bank_servicer.ts

 
class AccountServicer extends Account.Servicer {
 

2
  async deposit(context, state, request) {
 
    state.balance += request.amount;
 
    return {};
 
  }
 

 
  ...

... because Reboot has idempotency built-in and can safely distinguish retries so mutations are only performed once!

Transactional

Reboot apps are transactional by default. Write simple code by composing functions without having to worry about partial state updates!

Frontendrebank/web/App.tsx

 
const bank = useBank({ id: "Rebank" });
 

 
// Call any mutator on the backend.
1
await bank.transfer({
 
  fromAccountId,
 
  toAccountId,
 
  amount,
 
});

Any backend function can be a transaction which can be called from either the frontend or the backend.

Backendrebank/backend/bank_servicer.ts

 
class BankServicer extends Bank.Servicer {
 

2
  async transfer(context, state, request) {
 
    const from = Account.ref(request.fromAccountId);
 
    const to = Account.ref(request.toAccountId);
3
    await from.withdraw(context, { amount: request.amount });
 
    await to.deposit(context, { amount: request.amount });
 

4
    return {};
 
  }
 

 
 ...

When one of your transaction functions executes on the backend, either all of the functions it calls will update state ...

Or if one of them fails, then none of the other calls you made will commit any of their updated state.

When the function returns, the transaction commits and all state updates become permanent.

RealtimeRealtime

Fault-tolerant

Transactional

Reboot apps are reactive by default. Anytime state changes on the backend, your React frontend updates automatically. Multiplayer out-of-the-box, no polling necessary!

Frontendrebank/web/App.tsx

 
// Lookup durable types by ID.
 
const account = useAccount({ id: myAccountId });
 

 
// Use generated React hooks to get updates from
 
// the backend _reactively_.
1
const { response } = account.useBalance();
 

 
...

Reboot generates type safe React custom hooks that sync updates from the backend.

Backendrebank/backend/account_servicer.ts

 
class AccountServicer extends Account.Servicer {
 
  // Mutators update `state` directly, which gets durably
 
  // persisted when the function returns.
 
  async deposit(context, state, request) {
2
    state.balance += request.amount;
 
    return {};
 
  }
 

 
  async balance(context, state, request) {
3
    return state.balance;
 
  }
 

 
  ...

Any time backend state changes (e.g., someone calls Account.deposit)...

Faults are inevitable. Reboot makes it easy to call functions at least once, at most once, or exactly once. Just call your functions and let Reboot take care of the rest!

Frontendrebank/web/App.tsx

 
const payee = useAccount({ id: payeeAccountId });
 

 
// Will retry safely for retryable errors,
 
// e.g., network disconnects.
1
await payee.deposit({
 
  amount,
 
});
 

 
...

You don't have to worry about safely retrying mutations from the frontend, Reboot will retry for you ...

Backendrebank/backend/bank_servicer.ts

 
class AccountServicer extends Account.Servicer {
 

2
  async deposit(context, state, request) {
 
    state.balance += request.amount;
 
    return {};
 
  }
 

 
  ...

... because Reboot has idempotency built-in and can safely distinguish retries so mutations are only performed once!

Reboot apps are transactional by default. Write simple code by composing functions without having to worry about partial state updates!

Frontendrebank/web/App.tsx

 
const bank = useBank({ id: "Rebank" });
 

 
// Call any mutator on the backend.
1
await bank.transfer({
 
  fromAccountId,
 
  toAccountId,
 
  amount,
 
});

Any backend function can be a transaction which can be called from either the frontend or the backend.

Backendrebank/backend/bank_servicer.ts

 
class BankServicer extends Bank.Servicer {
 

2
  async transfer(context, state, request) {
 
    const from = Account.ref(request.fromAccountId);
 
    const to = Account.ref(request.toAccountId);
3
    await from.withdraw(context, { amount: request.amount });
 
    await to.deposit(context, { amount: request.amount });
 

4
    return {};
 
  }
 

 
 ...

When one of your transaction functions executes on the backend, either all of the functions it calls will update state ...

React developers,

own the full stack.

Reduce complexity and bugs,
increase reliability and scalability.

TypeScript

Python

Build backends using TypeScript and Python today. Request language ›

Streamlined development experience.

Build and iterate on your laptop.
Deploy the exact same code to the cloud for production.

Reboot is for your workflows too.

Long-lived business processes are a core part of every backend, with Reboot you don't need a separate tool to run them.

Backendrebank/backend/bank_servicer.ts

 
async wireTransfer(context: WorkflowContext, request) {
 

1
  await until("Human in the loop", context, async () => {
 
    return await checkSignOff(request.signOffDetails);
 
  });
 

 
  const account = Account.ref(request.fromAccountId);
 

 
  await account.idempotently()
 
    .withdraw(context, { amount: request.amount });
 

2
  await atMostOnce("Remit to provider”, context, async () => {
 
    return http.post(REMITTANCE_PROVIDER_URL, {
 
      toAccountDetails: request.toAccountDetails
 
    });
 
  });
 

 
  await emailer.Message.idempotently().send(context, {
 
    to: request.transferCompleteEmail
 
  });
 

 
  return {};
 
}

Run blocks of code that will reactively re-execute until a condition is met.

Run blocks of code that will only be tried atMostOnce (or, not shown, atLeastOnce).

Create and share your durable data structures.

Need a distributed dictionary? Just import SortedMap from Reboot's standard library.

Build your backends by composing data structures, similar to composing React components on the frontend.

Backendmy-new-app/scalable.ts

 
import { SortedMap } from "@reboot-dev/reboot-std/collections/sorted_map.js";
 

 
...
 

 
const map = SortedMap.ref(someId);
 

 
...
 

 
await map.insert(context, { entries: { "someKey": someValue } });
 

 
...
 

 
await map.get(context, { key: "someKey" });

Get the latest updates.