Ethereal Inc.

Ethereal Inc.

We build Paybrain.

The software company behind Paybrain, a point-of-sale and invoicing system for independent businesses: restaurants, shops, salons, gyms and freelancers. We also build the frameworks our products run on.

The Paybrain register: a touchscreen on a cash drawer, with a barcode scanner and receipt printer

Paybrain

The Paybrain register, seen from the front

The register

Everything in the box.

A 15-inch touchscreen, cash drawer, receipt printer, barcode scanner and card reader. $999, with the software included.

The software

The software is the product.

Every register runs CerebrOS: tabs and kitchen display, barcodes and stock counts, booking, memberships, invoicing, payroll and loyalty. New features ship to every counter.

The price

One price per payment.

3.0% + 10¢ per transaction. No monthly software fee, no contracts. Free to start on a phone with Tap to Pay.

A Paybrain register on a café counter, next to an espresso machine

Built for the counter

Made for the places that still take cash.

Paybrain is sold as hardware you buy once rather than a subscription, and the same software runs the register, the web and the phone.

  • Restaurants and cafés
  • Retail
  • Salons and med-spas
  • Gyms and clubs
  • Professionals and freelancers
  • Online stores

Built in-house

We write much of our own tooling.

These are the main pieces. None of them is sold off the shelf today; if one would be useful to you, get in touch.

Futurio

A backend framework for Node.js. Each endpoint is declared once with a Zod contract, the handler is type-checked against it, and a generated client gives the frontend the same types.

See how it works

FuturioDB

An in-memory relational database for real-time features. Tables are declared in code, and reactive streams push every insert, update and delete to your handlers as they happen.

See how it works

EtherealAuth

Face-based sign-in for the browser: a Node.js SDK and React components for registering and authenticating users with the device camera, on top of whatever database you already use.

Internal

Futurio

Declare the contract once. Everything else is typed from it.

Futurio is our backend framework for Node.js. You declare each endpoint’s path, method and Zod contract once. The handler is type-checked against that contract, and one command writes a typed client for the frontend, with a React hook included.

01

Define the endpoint

Path, method and a Zod contract, declared once.

01 · Define the endpoint
import { z } from 'zod';

const getUser = futurio.endpoint({
  path: '/users/:id',
  method: 'GET',
  contract: {
    params: z.object({ id: z.string() }),
    response: z.object({
      id: z.string(),
      name: z.string(),
      email: z.string(),
    }),
  },
});

02

Write the handler

Type-checked against the contract. Return the wrong shape and it does not compile.

02 · Write the handler
import { db } from './database';

getUser.handler(async ({ params }) => {
  const user = await db.user.findUnique({
    where: { id: params.id },
  });

  if (!user) {
    throw new Error('User not found');
  }

  return {
    id: user.id,
    name: user.name,
    email: user.email,
  };
});

03

Generate the client

One command writes a typed client covering every endpoint.

03 · Generate the client
npx futurio generate

# Writes a typed client for every endpoint.
# Plain TypeScript, usable from any frontend.

04

Call it from the frontend

The frontend gets the server’s types, with a React hook included.

04 · Call it from the frontend
import { useFuturioQuery } from '@etherealio/futurio';
import api from 'connector';

function UserProfile({ id }) {
  // Also works with react-query
  const { data, error, isLoading } = useFuturioQuery(api.getUser, {
    params: { id },
  });

  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h1>{data.name}</h1>
      <p>{data.email}</p>
    </div>
  );
}

FuturioDB

Tables in code. Changes pushed to you.

FuturioDB is our in-memory relational database for real-time features. Tables are declared in code, queries chain like a builder, and streams push every insert, update and delete to your handlers, so connected clients stay current without polling. A small messenger as an example.

01

Declare the tables

Tables live in code, next to the logic that uses them.

01 · Declare the tables
import { FuturioDB } from '@etherealio/futurio';

const db = new FuturioDB({
  name: 'messenger_app',
  tables: {
    messages: {
      id: 'string',
      userId: 'string',
      roomId: 'string',
      content: 'string',
      timestamp: 'number',
    },
    users: {
      id: 'string',
      username: 'string',
      status: 'online' | 'offline' | 'away',
    },
  },
});

02

Subscribe to changes

Streams call your handlers on every insert, update and delete.

02 · Subscribe to changes
db.stream('messages')
  .where({ roomId: 'general' })
  .onInsert((message) => {
    websocket.broadcast('new-message', message);
  })
  .onUpdate((message) => {
    websocket.broadcast('message-updated', message);
  })
  .onDelete((message) => {
    websocket.broadcast('message-deleted', message.id);
  });

03

Insert, query, update

A chained query builder over in-memory tables.

03 · Insert, query, update
const message = await db.insert('messages', {
  id: generateId(),
  userId: currentUser.id,
  roomId: 'general',
  content: 'Hello world!',
  timestamp: Date.now(),
});

const recent = await db.select('messages')
  .where({ roomId: 'general' })
  .where({ timestamp: { $gt: Date.now() - 3600000 } })
  .orderBy('timestamp', 'desc')
  .limit(50);

await db.update('users',
  { id: currentUser.id },
  { status: 'online' },
);

04

A messenger, end to end

Connected clients stay current without polling.

04 · A messenger, end to end
class MessengerService {
  constructor() {
    db.stream('messages').onChange((change) => {
      const { type, data, roomId } = change;
      this.broadcastToRoom(roomId, { type: `message-${type}`, data });
    });

    db.stream('users').onUpdate((user) => {
      this.broadcastUserStatus(user);
    });
  }

  async sendMessage(userId, roomId, content) {
    // The stream handler broadcasts it to clients
    return db.insert('messages', {
      id: generateId(),
      userId,
      roomId,
      content,
      timestamp: Date.now(),
    });
  }
}

Where we come from

Before starting Ethereal Inc., we built software at these companies.

  • Johnson Controls
  • Tyco
  • ADP
  • Office Depot
  • RMS
  • Pixability
  • Heave
  • Lennar

Contact

Say hello.

Questions about Paybrain, our technology, or working together? Write to us and we’ll get back to you.

What is it about?