Game Engine de Código Aberto · 0.5 preview

Jogos nativos a partir de TypeScript

Escreva TypeScript e publique jogos nativos sem navegador incorporado nem C++. A Bloom compila seu jogo ahead-of-time e o executa em Metal, DirectX 12, Vulkan e WebGPU — uma única base de código, nove alvos, renderização PBR de verdade e física prontos para uso.

main.ts
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();
}
0 Overhead de runtime
9 Plataformas-alvo
13 Subsistemas modulares
1 Base de código para manter

Por que a Bloom?

A Bloom compila jogos TypeScript ahead-of-time sobre um core em Rust. Os alvos nativos não usam Electron, WebView ou runtime de navegador incorporado; o alvo Web gera WebAssembly.

API Simples

A API de gameplay prioriza funções: dados simples, handles explícitos e chamadas diretas. Ferramentas especializadas adicionam apenas pequenas abstrações auxiliares.

Verdadeiramente Nativo

Um renderer, quatro backends — Metal, DirectX 12, Vulkan e WebGPU. Materiais PBR, sombras em cascata, TAA e post-FX inclusos.

Publique em Qualquer Lugar

macOS, Windows, Linux, iOS, tvOS, watchOS, visionOS, Android e Web a partir de uma única base de código.

Tudo o que você precisa

Treze subsistemas modulares, cada um importável de forma independente. Use somente o que você precisa.

Core

Criação de janela, game loop, tratamento de input, temporização e controle de frame.

@bloomengine/engine/core

Shapes

Desenho de formas 2D — linhas, retângulos, círculos, polígonos — além de detecção de colisão.

@bloomengine/engine/shapes

Textures

Carregamento de imagens, gerenciamento de texturas, batching de sprites e render-to-texture.

@bloomengine/engine/textures

Text

Carregamento de fontes TTF e OTF, renderização de texto e medição.

@bloomengine/engine/text

Audio

Efeitos sonoros, streaming de música, áudio posicional 3D, WAV / OGG / MP3.

@bloomengine/engine/audio

Models

Carregamento de glTF 2.0, animação esqueletal na GPU, materiais PBR, primitivas de mesh.

@bloomengine/engine/models

Math

Vetores, matrizes, quatérnios, funções de easing e geração de números aleatórios.

@bloomengine/engine/math

Physics

Corpos rígidos e moles com Jolt, controladores de personagem, veículos, raycasts, restrições.

@bloomengine/engine/physics

Scene

Scene graph em modo retido — transformações, visibilidade, sombras, vinculação de materiais.

@bloomengine/engine/scene

Mobile

Controles virtuais, áreas seguras e auxiliares de entrada por toque.

@bloomengine/engine/mobile

World

Carregamento e validação versionados de mundos, prefabs e instanciação em runtime.

@bloomengine/engine/world

VFX

Sistemas de partículas na GPU, emissores e decals.

@bloomengine/engine/vfx

Quality

Execuções de qualidade determinísticas, capturas e telemetria.

@bloomengine/engine/quality

Uma base de código. Toda plataforma.

A Bloom mapeia para a API gráfica nativa de cada plataforma através de um único renderer baseado em wgpu. Seu TypeScript compila para binários reais — ou para um bundle WASM para a web.

macOS
Metal
Windows
DirectX 12
Linux
Vulkan
iOS
Metal
tvOS
Metal
watchOS
SwiftUI / SceneKit
visionOS
Metal
Android
Vulkan / OpenGL ES
Web
WebGPU / WebGL

Feito com Bloom

O primeiro jogo Bloom já está disponível

Bloom Jump, um jogo de plataforma retrô em pixel art gratuito, foi feito inteiramente com Bloom — uma única base de código TypeScript rodando nativamente no iPhone, iPad e Mac. Cinco níveis feitos à mão, 60 FPS e trilha sonora chiptune original.

Baixar na App Store iPhone · iPad · Mac
Gameplay de Bloom Jump no Mac

Novidades

A Bloom está em desenvolvimento ativo — mais de 300 commits só nas últimas semanas. Destaques recentes:

Renderer

Auto-DRS e sharpen com CAS

A escala de renderização dinâmica se ajusta automaticamente ao seu FPS-alvo, com um passe de upscale + RCAS sharpen para manter a nitidez em resoluções fracionárias.

Materials

Reflexões planares + arrays de texturas

Reflexões planares estilo espelho com oblique-clip e fallback IBL. Terreno com splat-map via vinculação de texture arrays com mips.

Tools

CLI de imposter baker

Atlas octaédricos para LODs distantes — publique florestas densas e multidões sem estourar seu orçamento de draw calls.

Post-FX

Passes de pós-processamento empilháveis

Tone mapping ACES / AgX, exposição automática, bloom, DoF, motion blur, SSGI, SSAO, TAA — compostos via render targets em ping-pong.

Platform

HiDPI multiplataforma

Windows, Linux e Web agora compartilham o mesmo tratamento de HiDPI que macOS e iOS já tinham. Sua UI permanece nítida em qualquer display.

DX

Hot reload de shaders WGSL

Salve um shader, veja o resultado em menos de um segundo. Materiais recompilam no lugar durante o desenvolvimento.

Padrões familiares, poder nativo

Interfaces simples, funções puras, zero mágica. Se você sabe TypeScript, você sabe Bloom.

Formas 2D e Colisão

import { drawRect, drawCircle,
         checkCollisionRecs } from "@bloomengine/engine/shapes";

drawRect(100, 100, 200, 80, Colors.GREEN);
drawCircle(400, 300, 50, Colors.GOLD);

if (checkCollisionRecs(player, enemy)) {
  playSound(hitSound);
}

Câmera 3D e Modelos

const camera: Camera3D = {
  position: { x: 10, y: 10, z: 10 },
  target: { x: 0, y: 0, z: 0 },
  up: { x: 0, y: 1, z: 0 },
  fovy: 45, projection: "perspective"
};

beginMode3D(camera);
drawModel(tree, { x: 0, y: 0, z: 0 }, 1.0, Colors.WHITE);
drawGrid(10, 1);
endMode3D();

Pronto para construir seu jogo?

A Bloom é open source e gratuita. Mergulhe, construa algo e publique em todo lugar.