Mateo Suárez.

Software Engineer

Creations

From low-level systems, custom runtimes, and game engines to high-performance web frameworks and ergonomic utilities.

BRPC

TypeScript

A type-safe, batteries-included RPC framework for Bun. End-to-end type safety like tRPC, with built-in WebSocket subscriptions, file serving, media streaming, S3 storage, and Auth services.

GitHub Docs

Key Features

End-to-End Type Safety

Inferred context and schema validation seamlessly connecting client and server.

WebSocket Pub/Sub

Real-time subscription procedures with direct client bindings.

Storage & Auth Built-in

S3 integration, image optimization, and JWT/OTP authentication out-of-the-box.

Streaming Media

Native HTTP Range support for scrubbable video and audio pipelines.

Ban Engine

C++ WIP

A game engine for people who want to write code. Data-oriented underneath, fluent on the surface. Built to run predictably on constrained hardware with architectural performance guarantees.

GitHub

Key Features

The Whole Game in Code

No visual scripting or bloated hierarchies. A direct, flat API that makes complex intentions simple.

Data-Oriented Design

Plain component structs operating over contiguous memory for maximum CPU cache efficiency.

Predictable Frame Times

LOD, culling, and streaming designed as architectural guarantees rather than patches.

Pass-Based GPU Renderer

Deferred PBR renderer with image-based lighting, procedural sky, and automatic LOD.

Odin-TS Runtime

Odin TypeScript WIP

A lightweight, embeddable TypeScript runtime built from scratch in Odin. No V8, no JS core. Compiles TS directly to typed bytecode.

Actively engineered as the ultra-performant scripting layer for Ban Engine and Flash-GPU, enabling hot reload and over-the-air updates without native binaries.

GitHub

Key Features

Zero Bridge Tax

Native types live in native memory. Scripts hold typed handles with direct pointer offsets.

Typed Bytecode VM

No Escape Hatches

Bans `any`, `unknown`, and `eval` at parse time for reliable AOT compilation.

Hybrid Powerhouse

Pairs seamlessly with Ban Engine and Flash-GPU for high-speed dynamic scripting.

Flash-GPU

C++ WIP

A GPU-native declarative UI framework with a reactive immediate-mode architecture.

Describe UI directly from state, turn it into render commands, and execute it through a pass-based GPU renderer.

Declarative like modern app frameworks. Immediate like game UI. Native to the GPU.

GitHub

Key Features

Zero Idle Cost

Reactivity schedules work only when something changes. Idle UI requests no frames.

Immediate Mode

Describe the UI from current state — no VDOM, retained widget synchronization, or manual update bookkeeping.

Shaders as Styles

Attach GPU effects directly to elements: blur, glass, bloom, distortion, masks, gradients, and custom shaders.

Retained Performance

Immediate-mode ergonomics without throwing work away. Flash caches and reuses data across frames where possible.

Architecture & Rendering

SDF Rendering — crisp scalable shapes and text
Custom Render Passes — extend the UI pipeline directly
Animations & Transitions — including shared-element transitions
Own Layout Engine — flex/grid-like composition, scrolling, sizing, etc.
Cross Platform — Desktop, Android, iOS, Web
C++ & Scripting — eventually TypeScript/TSX and other frontends

Flash

TypeScript

Fine-grained reactive JSX framework with zero VDOM overhead. Write familiar JSX, get direct DOM updates. Ships with first-class SSR, hydration, SEO management, and built-in exit animations.

GitHub Docs

Key Features

Zero VDOM

Updates the DOM directly using observables without diffing trees.

Reactive Boundaries

Wrap any JSX node in a function to isolate re-renders perfectly.

Animation Primitives

Built-in frame scheduler, FLIP animations, and `onBeforeExit` lifecycle.

First-Class SSR

Seamless Bun integration, async streaming, and SEO head management.

Query

TypeScript

A next-generation query and cache management system for React and React Native. Built on Legend State observables with incremental sync and production offline capabilities.

GitHub Docs

Key Features

Fine-grained Reactivity

Eliminates unnecessary re-renders using Observable-based state tracking.

Incremental Sync

Delta-based updates fetch only what changed, cutting bandwidth by 90%.

True Offline-First

Pluggable persistence for Web (IndexedDB) and Native (expo-sqlite).

Memory Safe

Pure event-driven architecture with automatic callback cleanup.

SurrealQB

TypeScript

A type-safe query builder for SurrealDB. Write expressive SurrealQL queries in TypeScript with native graph support and result types inferred directly from your schema.

GitHub Docs

Key Features

Schema Type Inference

Define tables once, get fully typed SELECTs, mutations, and projections.

Graph Traversal

Chainable multi-hop traversals natively reflecting SurrealDB graph paths.

Batch & Transactions

Execute multiple statements in a single WebSocket round-trip safely.

Zero Boilerplate

Automatic parameter binding and dot-notation for nested fields.

Event Emitter

TypeScript

A highly usable event emitter for modern TS/React apps. Forget messy prop-drilling or large contexts for simple signals—just create a typed event and listen anywhere seamlessly.

GitHub Docs

Key Features

Type-Safe Payloads

Define the shape of your event data once, use it everywhere safely.

React Hooks

Includes `useEvent` for safe, auto-disposing lifecycle attachment.

const someEvent = eventEmitter.createEvent<{ message: string }>("something");

useEvent(someEvent.listen, (data) => {
  // do something here
  console.log(data.message); 
});

About Me.

I am a Software Engineer and Social Educator. I believe that technology should be an enabler, not an obstacle. My engineering philosophy revolves around creating architectures that empower developers to build faster, safer, and with less cognitive load.

Whether I am building high-performance systems in C++ and Odin, or fully type-safe, fine-grained reactive frameworks in TypeScript, the goal is always the same: build the tools that I wish existed.