Ethereal Inc.
Portal Login

Pioneering Next-Generation Software

A cutting-edge technology company specializing in revolutionary payment processing and proprietary backend frameworks. We deliver enterprise-grade software solutions trusted by Fortune 500 companies and innovative startups alike.

Explore Our Solutions

Our Flagship Products

PayBrain.io

A bleeding-edge payment processing platform with integrated file sharing and intuitive features geared around creative businesses.

Visit Website

Futurio

A revolutionary full-stack development framework that automatically generates type-safe APIs, databases, and frontend clients from a single schema definition.

Learn More

FuturioDB

A revolutionary database engine designed for next-generation applications with unparalleled performance and scalability.

Learn More

EtherealAuth

Browser-based facial recognition authentication system with Node.js SDK, React components, and database-agnostic architecture for seamless biometric account registration.

Learn More

EtherealAuth: Next-Gen Biometric Authentication

Revolutionary facial recognition system that replaces passwords with secure, instant biometric authentication. Built for developers, designed for users.

Browser Camera Integration

Seamless facial recognition through any modern web browser without plugins or downloads.

Database Agnostic

Works with any database system - MySQL, PostgreSQL, MongoDB, or your custom storage solution.

Node.js Developer SDK

Complete TypeScript/JavaScript SDK with comprehensive documentation and code examples.

Drop-in React Components

Pre-built React components for facial registration, login, and account management workflows.

Why Choose EtherealAuth?

  • Eliminate password security risks
  • Reduce support tickets by 90%
  • Instant user authentication
  • GDPR & CCPA compliant
  • Enterprise-grade security
  • Real-time liveness detection

Quick Integration

npm install @etherealio/futurio

import { FaceAuth } from '@etherealio/futurio'; function LoginPage() { return ( <FaceAuth onSuccess={(user) => setUser(user)} onError={(error) => console.error(error)} liveness={true} confidenceThreshold={0.85} /> ); }

Trusted by Industry Leaders

Fortune 500 companies and innovative businesses rely on our technology solutions

Johnson ControlsTycoADPOffice DepotRMSPixabilityHeaveLennar

Proprietary Technologies

At Ethereal Inc., we've developed cutting-edge technologies that power our production applications. Our proprietary stack enables us to build faster, more reliable, and highly scalable solutions that give us a competitive edge in the market.

Futurio: Type-Safe APIs Made Simple

Futurio is a powerful, private-licensed backend framework for Node.js (16x+) that streamlines API development. Define your endpoints and data contracts, and let Futurio generate a fully type-safe, framework-agnostic client. It even includes an out-of-the-box React hook for seamless integration.

1. Define Your API Endpoint

// Define your API endpoint using Zod for schema validation
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(),
    }),
  },
});

2. Implement Handler Logic

// Implement the handler for your endpoint
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,
  };
});

3. Generate the connector

// Generate the type-safe connector
npx futurio generate

// This creates a fully typed client with all your endpoints
// Ready to use in any frontend framework!

4. Use in Your Frontend

// Use the type-safe client in your frontend
import { useFuturioQuery } from '@etherealio/futurio';
import api from 'connector';

function UserProfile({ id }) {
  // You can use react-query as well
  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: Ultra-Fast In-Memory Database

FuturioDB is our proprietary in-memory relational database designed for real-time applications. Built for speed and simplicity, it uses reactive streams to instantly push data changes to your handlers. Perfect for messengers, live dashboards, gaming, and any application requiring instant data synchronization.

1. Initialize Your Database

// Initialize FuturioDB instance
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'
    }
  }
});

2. Set Up Stream Handlers

// Subscribe to data changes with streams
db.stream('messages')
  .where({ roomId: 'general' })
  .onInsert((newMessage) => {
    // Push new message to all connected clients
    websocket.broadcast('new-message', newMessage);
  })
  .onUpdate((updatedMessage) => {
    // Handle message edits
    websocket.broadcast('message-updated', updatedMessage);
  })
  .onDelete((deletedMessage) => {
    // Handle message deletions
    websocket.broadcast('message-deleted', deletedMessage.id);
  });

3. Perform Fast Operations

// Lightning-fast CRUD operations
// Insert new message
const newMessage = await db.insert('messages', {
  id: generateId(),
  userId: currentUser.id,
  roomId: 'general',
  content: 'Hello world!',
  timestamp: Date.now()
});

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

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

4. Real-time Messenger Example

// Complete real-time messaging implementation
class MessengerService {
  constructor() {
    this.setupStreams();
  }

  setupStreams() {
    // Stream all message changes
    db.stream('messages').onChange((change) => {
      const { type, data, roomId } = change;
      
      // Broadcast to room participants only
      this.broadcastToRoom(roomId, {
        type: `message-${type}`,
        data
      });
    });

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

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

Contact Us

Get in touch with Ethereal Inc. Whether you're an investor, potential partner, or have questions about our products, we'd love to hear from you. Please select your inquiry type and we'll get back to you promptly.

We'll get back to you within 24 hours. For urgent matters, please include that in your message. All communications will be kept confidential.