Bloom Engine

Native games from TypeScript.

Write TypeScript. Ship native games — and now the web too. Bloom compiles your game to Metal, DirectX 12, Vulkan, OpenGL, and WebGPU — one codebase for every platform.

Inspired by raylib. Bloom models its public API on raylib's — in our view one of the best API designs in gamedev. Bloom is an independent implementation, not a port — how Bloom relates to raylib »

Install

npm install @bloomengine/engine

Or with your preferred package manager:

bun add @bloomengine/engine
pnpm add @bloomengine/engine
yarn add @bloomengine/engine

The npm package ships the TypeScript API alongside the engine's Rust sources and the bundled JoltPhysics C++ shim, so a single install is enough — there's no separate native download step.

You'll also need:

• Perry — the TypeScript AOT compiler that turns your game into a native binary or WASM module. It also drives the engine's native build.
• Rust toolchain (rustup.rs) — Perry invokes Cargo to compile the engine's platform crate the first time you build for each target.
• For web builds only: wasm-pack (cargo install wasm-pack).

Quick Start

import { initWindow, windowShouldClose, beginDrawing,
         endDrawing, clearBackground, drawText, Colors } from "@bloomengine/engine";

initWindow(800, 450, "My Game");

while (!windowShouldClose()) {
  beginDrawing();
  clearBackground(Colors.SNOW);
  drawText("Hello, Bloom!", 190, 200, 20, Colors.DARKGRAY);
  endDrawing();
}

Web-Compatible Pattern

Use runGame() for code that works on both native and web:

import { initWindow, runGame, clearBackground, drawText, Colors } from "@bloomengine/engine";

initWindow(800, 450, "My Game");

runGame((dt) => {
  clearBackground(Colors.SNOW);
  drawText("Hello, Bloom!", 190, 200, 20, Colors.DARKGRAY);
});

Build for web:

./native/web/build.sh main.ts
cd dist/web && python3 -m http.server 8080

Features

• Simple API — Functions, not classes. The entire API fits on a cheatsheet. (design rationale)
• True native — Compiles to Metal, DirectX 12, Vulkan, OpenGL, and WebGPU via wgpu.
• Ship everywhere — macOS, Windows, Linux, iOS, tvOS, Android, and Web from one codebase.
• Unified 2D/3D — Shapes, textures, text, 3D models, and audio in one engine.
• Zero magic — Explicit game loops, no hidden framework overhead.

How Bloom relates to raylib

Bloom's public API is heavily inspired by raylib. raylib's API is, in our opinion, one of the best in the gamedev space — a flat library of plain functions, no classes, small enough to learn from a cheatsheet — so we model ours on it. You'll recognize the shape immediately: initWindow, beginDrawing, clearBackground, drawText, and modules named core / shapes / textures / text / audio / models.

That's where the relationship ends. Bloom's implementation is entirely independent — it does not link against, embed, or call raylib. Bloom compiles TypeScript directly to native code via Perry, our LLVM-based AOT compiler, and renders through wgpu (Metal, DirectX 12, Vulkan, OpenGL, WebGPU). It is not a port or a binding — just an engine that admires raylib's API design. Thanks to Ramon Santamaria (@raysan5) and the raylib community for setting the bar. (full design rationale)

Modules

| Module | Import | Description | |--------|--------|-------------| | Core | @bloomengine/engine/core | Window, game loop, input, timing | | Shapes | @bloomengine/engine/shapes | 2D drawing + collision detection | | Textures | @bloomengine/engine/textures | Image loading, sprite batching | | Text | @bloomengine/engine/text | TTF/OTF font loading and rendering | | Audio | @bloomengine/engine/audio | Sound effects + music streaming | | Models | @bloomengine/engine/models | 3D model loading (glTF, OBJ), skeletal animation | | Math | @bloomengine/engine/math | Vectors, matrices, quaternions, easing | | Physics | @bloomengine/engine/physics | Jolt-backed rigid + soft bodies, character, vehicles (docs) |

Platforms

| Platform | Graphics API | Input | |----------|-------------|-------| | macOS | Metal | Keyboard + mouse | | Windows | DirectX 12 | Keyboard + mouse | | Linux | Vulkan / OpenGL | Keyboard + mouse | | iOS | Metal | Touch + gamepad | | tvOS | Metal | Siri Remote + gamepad | | Android | Vulkan / OpenGL ES | Touch + gamepad | | Web | WebGPU / WebGL | Keyboard + mouse + touch + gamepad |

Architecture

src/                  TypeScript API
  core/               Window, input, game loop
  shapes/             2D shapes + collision
  textures/           Image loading, sprites
  text/               Font rendering
  audio/              Sound + music
  models/             3D models
  math/               Vectors, matrices, easing

native/               Rust implementations
  shared/             Cross-platform core (wgpu, fontdue, gltf)
  macos/              Metal + AppKit + Core Audio
  ios/                Metal + UIKit + Core Audio
  tvos/               Metal + UIKit + GCController
  windows/            DirectX 12 + Win32 + XAudio2
  linux/              Vulkan/OpenGL + X11/Wayland + PulseAudio
  android/            Vulkan/OpenGL ES + NativeActivity + AAudio
  web/                WebGPU/WebGL + Canvas + Web Audio (WASM)

examples/
  pong/               Complete working example (~170 lines)

Types

Plain interfaces, no classes:

interface Vec2 { x: number; y: number }
interface Vec3 { x: number; y: number; z: number }
interface Color { r: number; g: number; b: number; a: number }
interface Rect { x: number; y: number; width: number; height: number }
interface Camera2D { offset: Vec2; target: Vec2; rotation: number; zoom: number }
interface Camera3D { position: Vec3; target: Vec3; up: Vec3; fovy: number; projection: number }
interface Texture { handle: number; width: number; height: number }
interface Sound { handle: number }
interface Model { handle: number }

Fullscreen

Launch your game in fullscreen by passing true as the fourth argument to initWindow:

initWindow(800, 450, "My Game", true);   // launches fullscreen
initWindow(800, 450, "My Game");         // windowed (default)

Toggle fullscreen at runtime:

if (isKeyPressed(Key.F11)) {
  toggleFullscreen();
}

Fullscreen is supported on macOS (native AppKit fullscreen), Windows (borderless fullscreen), and Linux (EWMH/X11). The width and height you pass are used as the windowed dimensions when exiting fullscreen.

Skeletal Animation

Bloom supports GPU-accelerated skeletal animation via glTF/GLB models. The pipeline uses 4-bone linear blend skinning with a 128-joint uniform buffer, running entirely on the GPU.

import { loadModel, loadModelAnimation, updateModelAnimation, drawModel,
         getTime, Colors } from "@bloomengine/engine";

const character = loadModel("assets/models/character.glb");
const anim = loadModelAnimation("assets/models/character.glb");

// In your game loop:
updateModelAnimation(anim, 0, getTime(), 1.0, 0, 0, 0);
drawModel(character, { x: 0, y: 0, z: 0 }, 1.0, Colors.WHITE);

Key functions:

• loadModel(path) -- loads GLB with skin data (JOINTS_0, WEIGHTS_0)
• loadModelAnimation(path) -- loads skeleton + animation channels from GLB
• updateModelAnimation(handle, animIndex, time, scale, px, py, pz) -- samples animation, computes joint matrices
• drawModel(model, position, scale, tint) -- renders with GPU skinning

For the full pipeline (Blender export, pitfalls, architecture), see docs/skeletal-animation.md.

Links

• bloomengine.dev
• Docs
• Showcase
• Brand Guidelines