ASE - Antares Simulation Engine · Construa MMORPGs guiados por LLM. Como uma só pessoa.

// Escala por design

Um planeta não é uma fase.

Engines clássicas carregam uma fase, executam e descartam. ASE administra um planeta persistente: o modelo de mundo é projetado para bilhões de entidades e transmitido chunk por chunk.

deserto - **cada faixa climática, simulada**

cloudforest — floresta nublada - **uma amostra dos modelos de bioma da engine**

coralreef — recife de coral - **cada faixa climática, simulada**

rainforest — floresta tropical - **uma amostra dos modelos de bioma da engine**

mountains — montanhas - **cada faixa climática, simulada**

tundra - **uma amostra dos modelos de bioma da engine**

mangrove — manguezal - **cada faixa climática, simulada**

oceano - **uma amostra dos modelos de bioma da engine**

Bilhões

Entidades no modelo de mundo

0

Reconexões no handoff de World

0

Módulos de sim. L3

0

Plugins L4

0

Schedules nomeados

0

Tiers de execução

cada planta uma entidade

Um campo vive por conta própria

Num campo em ASE cada planta é uma entidade: germina, floresce, dá frutos e morre. Florestas crescem ao longo de anos e decaem de novo. Nada disso espera por plateia - e o custo de computação segue a densidade de simulação, não o número de jogadores: um vale densamente simulado sem um único jogador pode custar mais que uma planície cheia de jogadores.

GIS layers

Um mundo modelado como um serviço de mapas

O terreno é uma grade de chunks de heightmap com camadas de dados geográficos - elevação, umidade, temperatura, bioma, geologia. Clima, vegetação e criaturas leem essas camadas e reagem; mutações de terreno as escrevem de volta. O planeta é um conjunto de dados compartilhado e em camadas.

EnTT → MongoDB

Carregado sob demanda

Chunks são criados e liberados dinamicamente conforme os jogadores se movem pelo mundo, com streaming de LOD por distância. Chunks descarregados ficam persistidos no MongoDB, esperando. E toda mudança de terreno é transmitida pelo hub para clima, vegetação e criaturas - o mundo reage como um todo.

Chunks de 32×32

O chunk é a unidade de tudo

O mundo é particionado em chunks de heightmap: carregados ao redor dos jogadores, alterados por erosão, clima e jogadores, persistidos no MongoDB quando ociosos. Regiões de chunks também são a unidade de escala horizontal - um servidor World possui um conjunto de coordenadas de chunks, nada mais.

66 schedules / 21 camadas

A economia da tick-rate

Cada sistema declara seu ritmo: sistemas do tier Frame rodam a 60 Hz, Kinetic a 30 Hz, Cyclic a 1 Hz - 66 schedules nomeados em 21 camadas. Plantas não pensam na taxa de quadros, e é justamente não acelerar processos lentos que libera a CPU para carregar um planeta.

um planeta, simulado

A meta, dita sem rodeios

Planetas inteiros com ecossistemas, cada planta uma entidade, física real, clima e fluidos, número de jogadores escalando horizontalmente por região de chunks - não a renderização de um mundo, mas a simulação de um.

O(n), não O(n²)

Escala é linear por design

Como os sistemas escrevem em componentes compartilhados em vez de se conectarem uns aos outros, adicionar entidades e adicionar comportamento custam ambos de forma linear. Escala não é uma parede contra a qual você otimiza depois - é a forma do modelo de dados desde a primeira linha.

player_muts: 0

O mundo não pausa

O mundo se simula sem jogadores - no log de terreno, player_muts: 0 o caso normal. A erosão continua escavando, o clima continua se movendo, as plantas continuam crescendo - com alguém conectado ou não.

entity-per-item

Sem arrays, sem tetos

Components não têm arrays nem contagens: uma molécula com N elementos são N entidades, uma floresta são suas árvores. As estruturas são ilimitadas porque uma query, não um slot fixo, as percorre - o modelo de dados recusa um limite rígido.

Neo4j + MongoDB

Dois armazenamentos, um mundo

Relações, hierarquias e inventário vivem em um grafo Neo4j; chunks, estado e snapshots fazem streaming para o MongoDB. Bancos de dados são apenas persistência - toda entidade ativa vive na RAM, então a simulação nunca espera uma query para dar tick.

Arquitetura ECS: O(n) onde engines orientadas a objetos são O(n²). Isso é possível vs. impossível - não apenas “mais rápido”.

// Tudo está conectado

Nova causalidade custa um campo de Component. Nenhuma refiação.

O axioma fundador é arquitetura, não um slogan: tudo é conectado, tudo é Entity, tudo é simulado. Para uma CPU executar isso, vale uma disciplina dura - sistemas nunca chamam uns aos outros. Eles se comunicam exclusivamente por Components.

10 billion

OOP - caminhos de conexão possíveis com 100k entidades

colapsa para →

100k

ASE - lookups de component por sistema e tick, o mesmo mundo

As primitivas

Entity · Component · System 3: Uma Entity é apenas um ID, um Component é dado puro sem métodos, um System é lógica de tick sem estado - a espinha rígida que permite a engine tratar cada folha e bactéria como um objeto de primeira classe.
Components são dado puro POD: Dado simples, sem métodos, sem .cpp - zero-inicializado, responsabilidade única. Comportamento nunca se esconde dentro do dado; ele vive em sistemas sem estado. Essa disciplina é o que mantém um bilhão de entidades barato.
Tudo Pode, Nada Deve: Qualquer entidade PODE carregar qualquer componente; nenhuma DEVE. Uma rocha que ganha um MetabolismComponent começa a metabolizar - sem classe, sem herança, sem factory. Capacidade é anexada, nunca declarada de antemão.
Tags em vez de flags de tipo: Sem campo type uint8_t, sem dispatch if-else. Uma view PredatorTag roda lógica de predador, uma view PreyTag roda lógica de presa - novo comportamento é uma nova tag mais um novo sistema, não um branch em um antigo.
Uma view é uma query, não um loop: Sem switch, sem dispatch manual. Um sistema abre uma view filtrada por tag e itera exatamente as entidades que correspondem - comportamento selecionado por quais componentes uma entidade carrega, resolvido pela própria query.

Acoplamento

O(n²) → O(n) caminhos→lookups: Com 100k entidades, OOP tem dez bilhões de caminhos de conexão possíveis. Em ECS o mesmo mundo são 100k lookups de component por sistema e tick. Adicione um elo causal escrevendo um campo; todo leitor reage automaticamente.
Components são o único canal: Sistemas nunca chamam uns aos outros - proibido. ase-sky pode influenciar ase-metabolism através de ase-predator sem que nenhum dos três se conheça pelo nome. As chaves compartilhadas do Hub são o contrato inteiro.
O Hub é uma estrela, não uma malha: 83 módulos L3 escrevem e leem através de um único Communication Hub - uma estrela com zero acoplamento direto módulo-a-módulo. Adicionar um módulo adiciona raios ao centro, nunca arestas aos outros.
Sistemas não possuem estado: Um System não guarda variáveis-membro e não mantém nada entre ticks - ele lê componentes, escreve componentes, pronto. A ausência de estado torna os sistemas trivialmente paralelos e infinitamente componíveis.
Paralelo porque sem estado: Sem estado mutável compartilhado entre sistemas, o scheduler roda sistemas independentes entre os núcleos sem locks. Concorrência não é parafusada por cima - ela decorre da mesma disciplina que remove as conexões.

O modelo de dados

Novo comportamento = novo dado 0 recompilações: O schema vive no dado, não no código. Adicionar um tipo ou comportamento significa criar entidades e anexar componentes. Arrays dentro de componentes são proibidos, então as estruturas permanecem ilimitadas - zero rebuild.
Entity-per-Item, nunca arrays: Components não têm arrays nem contagens. Uma molécula com N elementos são N entidades, cada uma com tag - as estruturas são ilimitadas e uma query, não um loop, as percorre. O modelo recusa slots fixos.
Orientado a dados, não hardcoded: Fórmulas leem campos de componentes; sem números mágicos, sem casos especiais. Uma nova espécie, clima ou economia é novo dado - nunca um branch enterrado em um sistema.
Sem herança, apenas composição: Não há hierarquia de classes. Um morcego não é uma subclasse de animal - é uma entidade carregando componentes Wings, Echolocation e Metabolism. Novos tipos são novas combinações, nunca uma nova classe base.
Determinístico apenas a partir das entradas: Forneça as mesmas entradas e o mundo se desenrola de forma idêntica. Como o estado muda apenas através de componentes e intents registrados, uma execução é reproduzível e re-executável - a fundação sobre a qual toda a engine repousa.

Runtime & escala

66 schedules, 21 tiers: O tick não é um único loop. Um scheduler em camadas próprio ordena cada sistema em 66 schedules nomeados em 21 camadas - de init once-per-life a frames de 60 Hz. Um scheduler de desenho próprio.
Dois relógios: tempo real e tempo de jogo: Cada schedule declara se segue o tempo real ou o calendário de jogo antariano. Cada sistema roda na cadência que seu fenômeno precisa - assim planta e montanha dividem um mundo a baixo custo.
Bilhões na RAM, transmitidos para o disco RAM→MongoDB: Cada entidade ativa vive na RAM dentro do EnTT; o MongoDB persiste chunks, estado e snapshots quando não são necessários. Escala é um problema de streaming - e a arquitetura é construída em torno disso.
O mesmo ECS nos dois lados do fio: EnTT no servidor C++, becsy no navegador, paridade 1:1 para componentes SHARED. Um sistema SHARED recalcula deterministicamente em vez de enviar seu resultado.
Não há gráficos sem significado: O sol não é uma fonte de luz - é um reator de fusão cuja saída dirige a fotossíntese, a temperatura do solo, a evaporação e o humor de cada criatura. Todo visual é a superfície de uma simulação.
Um arquivo, um sistema: Cada sistema é um único arquivo sem estado registrado em um schedule nomeado. Ler o arquivo diz exatamente quando ele roda e quais componentes ele toca - sem registro oculto, sem god-object orquestrando o resto.
Reativo por construção: Hooks on_construct e on_destroy disparam no momento em que um componente é adicionado ou removido, então as reações são ligadas a mudanças de dados em vez de consultadas a cada tick. Anexar um componente é em si um evento.

// Onde estamos

Construído às claras. Amadurecendo a cada dia.

Todo componente carrega um status em seu registro VERSION - e ele não é alegado, é auto-derivado da contagem de commits do componente. Isto é exatamente onde a ASE está hoje, não uma promessa. Arquitetura e visão estão de pé; a implementação está em andamento - publicamente rastreável, commit por commit.

seed → poc → init → core → feat → refine é calculado automaticamente a partir da contagem de commits de cada componente; alpha · beta · stable são definidos à mão. Clique em qualquer status para ver exatamente quais componentes estão ali - direto dos registros VERSION.

// O grafo ao vivo

Puxe um fio, o mundo inteiro se move.

Todo módulo vive em um grafo. Clique em um bloco abaixo - o grafo ao vivo se reconecta à cadeia downstream real daquele módulo, extraída direto dos docs de causalidade da engine. Quando atmosphere.temperature cai abaixo de genetics.cold_tolerance, um animal congela - dois módulos, zero acoplamento direto, uma regra de comparação no hub.

grafo ao vivo · ase-weather → 8 módulos

Um módulo pulsa. O mundo inteiro responde.

Puxe o clima

ase-atmosphere · 5

Pressão, temperatura, vento, neblina e chuva se ramificam em dificuldade de respiração, visão, propagação de cheiro, comportamento das aves e o céu. Reduza um campo e cinco módulos respondem.

Puxe o sol

ase-ephemeris · 5

A posição do sol e da lua dirige o céu celeste, as criaturas circadianas, as marés através de nautical, o render e até os eventos celestes da religião.

Puxe a terra

ase-gis · 8

A geografia semeia o terreno, o clima local, a seleção, a expressão de traços, os habitats, a primeira vida, o pathing e onde a fauna é posicionada - oito módulos downstream a partir de um mapa.

Puxe o metabolismo

ase-metabolism · 6

Os balanços de energia definem forrageamento, sobrevivência, cheiro, resistência de movimento, taxa de cura e toda decisão movida pela fome. A economia do corpo é lida de seis maneiras.

Puxe o céu

ase-celestial · 4

Dia e noite mudam o comportamento da IA, as janelas de atividade na cadeia alimentar, o alcance visual através da percepção e o render do céu. O relógio no alto move o chão embaixo.

Puxe o cheiro

ase-signature · 4

Uma trilha de cheiro dirige os predadores que a seguem, a busca por presas na cadeia alimentar, a percepção estendida e a identidade social. O olfato é causal, não cosmético.

Puxe uma luta

ase-combat · 4

Um golpe remodela a intenção através da camada BDI, queima energia metabólica, derrama sangue que carrega cheiro e resulta em um ferimento. A violência se propaga por quatro sistemas.

Puxe uma vida

ase-lifecycle · 3

Nascimento e morte movem as populações da cadeia alimentar, carregam uma alma e remodelam a resiliência através do ferimento conforme uma entidade envelhece. Uma única vida ecoa de três maneiras.

Puxe os genes

ase-genetics · 3

Os genes alcançam de volta a primeira vida em abiogenesis e adiante os sentidos através de perception e o cheiro e as marcas através de signature. A herança está ligada nos dois sentidos.

Puxe a origem

ase-abiogenesis · 4

A primeira química inicia a desordem da entropia, a seleção da evolução, os genomas mais antigos e o começo do viver-e-morrer. A origem se entrelaça em toda a árvore.

Puxe a estação

ase-calendar · 5

A virada do calendário redefine o clima, posiciona o céu celeste, dirige a trajetória do sol através do ephemeris, tinge o render e avança o próprio relógio.

Puxe o corpo

ase-bbol · 7

O organismo alcança seus genes, o envelhecimento, o lutar e cansar, o receber dano, o aprender a agir, o decaimento e o dirigir comportamento - sete módulos downstream de um corpo.

Puxe a intenção

ase-bdi · 3

Uma crença-desejo-intenção compromete energia metabólica a um objetivo, foca os sentidos através de perception e molda a trilha de cheiro que um ator deixa para trás. A mente move o corpo.

Puxe uma skill

ase-skill · 5

A ação aprendida se conecta à aptidão herdada, a uma vida inteira de maestria crescente, ao corpo que a executa, à prática que mantém o decaimento afastado e aos processos base por baixo.

// Emergência, passo a passo

Começa com o clima. Termina com um assentamento inundado.

Nenhum script escreveu isto. A cadeia abaixo é o que a saída de um módulo faz com todo módulo downstream - porque eles compartilham um grafo.

A chuva cai.

from ase-weather → atmosphere & hydro

As plantas crescem.

a umidade do solo sobe → ase-plant metabolism

Os herbívoros florescem.

abundância de forragem → ase-creature populations

Os predadores seguem.

densidade de presas → ase-foodchain pressure

Os rios erodem.

carga de escoamento → ase-erosion & transporte de sedimento

Os assentamentos inundam.

migração de canais → ase-terrain & os mundos que você construiu sobre isso

Tudo a partir de UM module.

mude um único valor upstream - tudo downstream é re-simulado.

~10 linhas, 1 sistema

Uma nova causalidade é normalmente zero código novo

Para fazer a lua clarear a noite, um SkyMoonSystem escreve moon_contribution em SkyBrightnessComponent - ~10 linhas, um sistema. StarSystem, PredatorSystem e PlayerVisibility já leem o brilho, então todos mudam de comportamento sem serem tocados.

estrelas = perigo

Os jogadores aprendem jogando, não por tutorial

Muitas estrelas visíveis significam um céu escuro e sem lua onde os predadores emboscam; poucas estrelas significam um luar brilhante que os expõe. Leões caçam com mais sucesso na lua nova - a ASE simula a realidade, não Hollywood, e a ensina através do jogo.

sem script

Emergência, não coreografia

Nada nesta cadeia é scriptado. Cada passo é um sistema lendo um componente que outro sistema escreveu. A inundação não é um evento que um designer posicionou - é a soma do ciclo da água, do terreno e da chuva.

// A topologia de quatro tiers

Reasoning interpreta. World simula. Replica autoriza. Engine orquestra.

Inspirado no replication layer de Star Citizen - repensado de forma independente para equipes de uma pessoa: o estado do jogo vive no Replica, instâncias World são computação intercambiável, e o navegador fala exclusivamente com o Replica. Nunca com a Engine, nunca com uma World.

Engine

Plano de controle · :808x

Orquestra o ciclo de vida, lê manifestos de projeto, expõe uma API HTTP tipada para o ase CLI e CI apenas. Conduzido CLI-first, como kubectl ou gh: promoção de build, início de projeto, smoke test e rollback são todos scriptáveis.

Replica

Plano de dados · :900x

Possui o estado autoritativo, persiste no MongoDB e é o único gateway público. Navegadores falam apenas com as portas do Replica. Autenticação, sessões, rate limiting e TLS vivem todos aqui - o Engine e o World não carregam nenhum modelo de auth público.

World

Plano de compute · :9001+

Roda os schedules da simulação e não guarda estado, persistência nem conexões de cliente. O nó que computa o estado não é o nó que o possui - então um World inicializa, se conecta ao dono do estado, se atualiza, produz e é desmontado como um web worker sem estado.

Reasoning

Plano de cognição · o 4º tipo

O trabalho não-determinístico baseado em linguagem que a simulação determinística estruturalmente não consegue produzir: saídas de skills, diálogo de NPC, geração narrativa, verificações de consistência de lore, roteamento semântico e anti-cheat comportamental. Nativo de LLM, por um tier dedicado - não um plugin.

Reasoning interprets

World simulates

Replica authorizes

Engine orchestrates

Engine :808x → Replica :900x (público) → World :9001+ + Reasoning navegadores alcançam apenas :900x

Planos & fronteiras

Quatro tipos de processo, um trabalho cada: Quatro binários distintos, não um monólito: Engine orquestra, Replica possui o estado e a superfície pública, World computa, Reasoning pensa. Um crash ou evento de escala em um é invisível para os outros - eles nunca compartilham um processo.
Três planos, uma responsabilidade cada control/data/compute: Engine orquestra o ciclo de vida; Replica possui o estado autoritativo e faz o gateway do público; World computa e não possui nada. Cada um é o menor processo que pode reiniciar sozinho sem derrubar os outros.
As portas esculpem a fronteira de confiança 808x / 900x / 9001+: As faixas de portas são o modelo de segurança. Navegadores alcançam apenas :900x; os planos de controle e compute são inalcançáveis pela internet pública por construção, não por política.
Cada tier é uma fronteira de observabilidade: Um pico de latência de broadcast aponta para o Replica, um pico de duração de tick para o World, um pico de ciclo de vida para o Engine. Dois tiers em um processo significam que uma falha em um leva o estado, os clientes ou o escalonamento junto.
Reasoning é o quarto tier: Ao lado de controle, dados e compute há um quarto plano para trabalho de linguagem - skills, diálogo, narrativa, roteamento semântico, anti-cheat comportamental. Escalável horizontalmente e com cota em seus próprios termos, não parafusado no loop.

Transporte & fio

Cinco transportes, cada um para uma propriedade tick de 10 Hz: HTTP/REST para CLI e CI; WS-Binary + BIN_MSG para servidor-a-servidor (o primeiro byte é o tipo, layout plano copiado com memcpy e zero alocações); WebRTC para navegadores (snapshots confiáveis, input não-confiável); SSE e WS-JSON não-padrão. Sob um orçamento de 10 Hz, binário zero-parse é correção.
O Hub é o namespace compartilhado: Os módulos escrevem e leem chaves nomeadas do Hub e o Almanach envia os deltas; nenhum módulo conhece outro pelo nome. 83 módulos L3 coordenam através de um Hub de topologia estelar, então adicionar um módulo nunca reconecta os outros.
Os wire ids vivem em um registro pre-reserved: Todo tipo de mensagem binária tem um id reservado em um registro de protocolo, alocado antes da implementação. Os tiers podem ser construídos em qualquer ordem e nunca colidem no fio - o contrato é escrito antes do código.
Deltas, não snapshots, em estado estável: Após um snapshot, o fio carrega apenas deltas na taxa de tick. Um sistema SHARED recalcula no lado do cliente em vez de receber resultados, colapsando ~100 B × 20 Hz para ~4 B × 1 Hz: envie a semente, não a imagem.

Disciplina

A disciplina de lanes é imposta, não aconselhada: Reasoning escreve apenas intents, World consome e escreve o estado, Replica autoriza, Engine orquestra. Uma skill que emite um intent não declarado é rejeitada no nível da engine - a restrição rígida que mantém um mundo re-executável.
CLI-first, como kubectl para um mundo scriptable: A superfície HTTP do Engine é construída para o ase CLI e CI primeiro - build-promote, project-start, smoke-test e rollback são scriptáveis. O console web é uma camada de conveniência sobre a própria mesma API.
Estado no Replica, o compute é fungível: Como o estado vive no Replica, qualquer World pode se conectar, se atualizar com os deltas e assumir. O plano que computa nunca é o plano que possui - exatamente o que torna possível o handoff perfeito, sem tela de carregamento.

// Contínuo em escala

Handoff Quantum-Travel: o compute troca no meio da região, você nunca vê uma tela de carregamento.

Como o navegador está conectado ao Replica e não ao World, a ASE pode mover, dividir e mesclar o compute por trás de uma região - um handoff de assinatura de tópico - enquanto o jogador continua andando. A continuidade não é um truque; ela decorre da topologia.

World Aem capacidade / migrando

1 boot 2 inscrever + snapshot 3 atualizar com deltas 4 assumir compute

World Bassume · sem reconexão

o jogador continua andando → o estado observável nunca falha

Handoff invisível, por construção

sem tela de carregamento

Quando um World se aproxima da capacidade ou precisa migrar, uma segunda instância inicializa, se inscreve nos mesmos tópicos do Replica, recebe um snapshot, se atualiza com os deltas e assume o compute. Os clientes não reconectam, não se re-autenticam, não veem uma tela de carregamento. A identidade de compute de uma região muda sem que seu estado observável mude.

Regiões quentes se dividem, regiões frias se mesclam - ao vivo

sem reinício

A partição de chunk-região não é fixa. Um scheduler adaptativo à carga subdivide uma região quente em dois Worlds ou colapsa duas regiões frias em uma a partir de telemetria ao vivo, porque reatribuir uma região é uma mudança de assinatura de tópico, não uma migração de estado. A forma da partição segue a densidade da simulação, não a contagem de jogadores.

Sem desaceleração, sem mundos divididos

Dois trade-offs clássicos de MMO são não-objetivos explícitos para ASE: a simulação nunca é desacelerada sob carga - computação horizontal mantém a taxa de tick constante - e um lugar cheio nunca gera uma segunda cópia desconectada de si mesmo. O mundo permanece um mundo.

Viagem entre projetos é apenas uma aresta

V-3 Verbund

Todo projeto vive em um grafo, então um cruzamento é uma relação entre dois nós, não uma exportação ou um job de sincronização. Uma caravana de comércio movendo-se do projeto A para o B não copia dado nenhum e não envia nenhuma mensagem inter-servidor - e o jogador não vê handoff nenhum, porque ambos os projetos são o mesmo grafo.

100.000+ projetos em um substrato

100,000+

Cem mil projetos compartilham o grafo unificado e o namespace compartilhado Hub/Almanach; cada um declara seus próprios grupos de Replica via manifesto. Sem provisionamento por projeto de bancos de dados ou compute - o custo do milésimo-primeiro projeto é similar ao do milésimo, porque o substrato não muda.

Três eixos de escala independentes

3 eixos

Vertical por processo, horizontal por papel (Replica por grupo de módulos, World por região de chunks) e a dimensão multi-projeto. O acoplamento é baseado em tópicos: um novo World é um novo inscrito, uma divisão de Replica é uma mudança de roteamento de tópico, um novo projeto é um novo label project_id. Nada disso toca no binário de outro tier.

O estado vive no Replica; o World é fungível

world sem estado

O nó que computa o estado nunca é o nó que o possui. Um World não guarda estado, persistência nem conexões de cliente - um worker de compute sem estado que pode ser substituído no meio da sessão sem que os jogadores percebam.

Zero reconexões por construção

0

A conexão do cliente vai para o Replica e nunca é derrubada quando a World atrás de uma região é trocada. Reconexões de jogadores durante migração: zero. Telas de carregamento durante migração: zero. O estado observável vive no Replica e simplesmente permanece lá.

Navegadores alcançam apenas o Replica

Superfície do Replica

O World (:9001+) e o Engine (:808x) são inalcançáveis pelo navegador; um navegador fala apenas com as portas do Replica. Autenticação, sessões, rate-limiting e TLS vivem todos nessa única superfície pública - os planos de compute e controle não carregam nenhum modelo de auth público.

Snapshot, depois deltas

snapshot + delta

Uma instância inicializando se inscreve nos tópicos do Replica da região, recebe um snapshot completo, se atualiza com o stream de deltas e só então assume o compute. A troca é invisível porque o estado observável nunca falha.

Cinco transportes, cada um para um trabalho

5 transportes

HTTP/REST para CLI e CI, WS-Binary para servidor-a-servidor, WebRTC DataChannel para navegadores (confiável para snapshots, não-confiável para input); SSE e WS-JSON permanecem deliberadamente não-padrão. Cada transporte é escolhido por uma propriedade sob um tick de 10 Hz.

Binário, zero-parse no fio

0 alloc

Frames servidor-a-servidor colocam o tipo da mensagem no primeiro byte e fazem memcpy de um layout plano direto no Hub/Almanach - zero alocações, sem parsing de JSON no hot path. Em um tick de 10 Hz isso é correção, não micro-otimização.

Um grafo, com escopo project_id

1 Neo4j

Todo projeto é um subgrafo rotulado em uma instância Neo4j - sem banco de dados por projeto, sem silo. Relações entre projetos são matches Cypher sobre labels, então uma caravana cruzando mundos é uma aresta, não uma integração.

Cada tier é uma fronteira de observabilidade

planos isolados

Um pico de latência de broadcast aponta para o Replica, um pico de duração de tick para o World, um pico de latência de ciclo de vida para o Engine - porque os planos nunca compartilham um processo. Uma falha em um não pode levar o estado, os clientes ou o escalonamento junto.

A partição segue a densidade, não a contagem de cabeças

malha adaptativa

O scheduler adaptativo à carga remodela a partição de chunk-região a partir de telemetria ao vivo: uma região densa e movimentada ganha mais Worlds, uma vazia é dobrada e removida. A malha rastreia onde a simulação está pesada, não onde os jogadores são contados.

Cresce em uma malha em runtime

sem reinício

Um projeto que começa em um único World se torna uma malha multi-instância durante seu próprio runtime. Reatribuir uma região é uma mudança de assinatura de tópico - sem reinício, sem migração de estado, sem janela de downtime.

O jogador nunca reconecta

sessão intocada

Através de uma divisão, uma mesclagem ou uma migração completa, a conexão do cliente com o Replica nunca é derrubada. Sem reconexão, sem re-autenticação, sem tela de carregamento - o compute por trás da região mudou, mas a sessão e seu estado observável não.

Elástico por região, a partir de telemetria

auto-scaled

A capacidade segue telemetria ao vivo sem operador no loop: uma região movimentada sobe mais Worlds, uma tranquila é dobrada e removida, continuamente. O escalonamento rastreia onde a simulação está de fato pesada, momento a momento.

O compute segue a multidão, a posse não

o estado fica no lugar

Onde os jogadores se reúnem, mais Worlds se conectam aos tópicos do Replica daquela região para dividir a carga. O dono do estado - o Replica - nunca se move; apenas o compute fungível se move. A densidade remodela a malha, não a fonte da verdade.

// Uma fonte, ambos os lados do fio

Escreva a simulação uma vez em C++. Um transpilador faz crescer seu gêmeo TypeScript.

ase-codegen faz o parse do backend C++ e gera o cliente becsy - componentes, sistemas e constantes - com paridade 1:1. A mesma lógica determinística então roda no servidor e no seu navegador, que é exatamente o que permite ao fio enviar uma semente em vez de uma imagem.

atmo_sim_prs_chg_sys.cpp C++ · EnTT

class AtmoSimPrsChgSystem
    : public ecs::System {
  void tick(Registry& r, float dt) {
    auto v = r.view<AtmoStPrsChgComponent,
                    AtmoStPrsBaseComponent>();
    for (auto [e, chg, base] : v.each()) {
      chg.timer_s += dt;
      if (chg.timer_s >= 60.0f)
        chg.delta = std::min(base.p, MAX_P);
    }
  }
};

AtmoSimPrsChgSystem.ts TS · becsy

@system(s => s.after(AtmoSimPrsAltSystem)
  .inAnyOrderWithWritersOf(AtmoStPrsChgComponent))
export class AtmoSimPrsChgSystem extends System {
  private readonly query = this.query(q => q.current
    .with(AtmoStPrsChgComponent).write
    .with(AtmoStPrsBaseComponent).read);
  execute(): void {
    const dt = this.delta;
    for (const e of this.query.current) {
      const chg = e.write(AtmoStPrsChgComponent);
      const base = e.read(AtmoStPrsBaseComponent);
      chg.timer_s += dt;
      if (chg.timer_s >= 60.0)
        chg.delta = Math.min(base.p, MAX_P);
    }
  }
}

registry.view<A,B>()→this.query(q => q.with(A).with(B))

view.each()→query.current

std::min / std::sin→Math.min / Math.sin

float x = 0.0f→let x: number = 0.0

float field→@field.float32

constexpr PI→const PI · importado (SSOT)

// por que fazemos isso - não para economizar digitação

Duas engines escritas à mão divergem na primeira vez que alguém corrige um bug em apenas um lado. Então a ASE nunca escreve duas: a lógica é escrita uma vez em C++ e o gêmeo TypeScript é transpilado a partir dela. Uma lógica nos dois lados é o que permite ao navegador recalcular o mundo a partir de uma semente em vez de transmitir a imagem, prever através de um pico de latência sem travar e permanecer travado ao servidor. Ele ainda deriva - ponto flutuante e previsão sempre derivam - mas o servidor autoritativo o traz de volta com deltas minúsculos, do jeito que o NTP disciplina um relógio de quartzo contra uma referência atômica. A mesma lógica é o que mantém a deriva pequena e a correção minúscula.

SHARED ambos os lados · 1:1

Components e sistemas determinísticos que existem no servidor e no cliente com campos idênticos. Estado que precisa renderizar - posição, pressão, saúde. Os sistemas transpilados vivem aqui.

SERVER-ONLY nunca enviado

Buffers, requests, broadcast, persistência e acesso ao Hub. Eles permanecem em C++ e nunca cruzam o fio, então o cliente não carrega nada do peso do servidor.

CLIENT-ONLY auto-generated

Sistemas NetworkInput, RenderSync e EntityExport que o codegen escreve para você - o encanamento que aplica os dados de rede ao ECS e os sincroniza no React.

Por que um transpilador, não uma segunda base de código

Lógica idêntica sobre dados idênticos: Ambos os lados rodam o mesmo algoritmo transpilado sobre os mesmos componentes SHARED, então o navegador prevê deterministicamente e permanece suave através de um pico de latência em vez de travar.
Envie a semente, não a imagem: Como o cliente recalcula em vez de receber resultados, o fio envia as entradas - colapsando ~100 B × 20 Hz de broadcast para ~4 B × 1 Hz. O cliente é o relógio de quartzo, o servidor é o relógio atômico: os deltas apenas o ajustam de volta ao compasso, eles nunca re-transmitem o mundo inteiro.
Uma fonte da verdade, sem deriva: O C++ é escrito; o TypeScript é gerado e marcado como não-editar. Um gêmeo de cliente mantido à mão pode silenciosamente sair de sincronia - um gerado não pode.
Type-safe através da fronteira: Todo tipo C++ mapeia para um decorator becsy - float to @field.float32, uint32_t to @field.uint32. Mude um campo em C++ e o tipo do cliente se remodela ao regenerar.
As constantes têm um único lar: Uma constante vive uma única vez - em hub/data ou no types.hpp de um módulo. O mesmo nome em dois módulos é um erro de build, não uma divergência silenciosa entre servidor e cliente.
SHARED não pode trapacear: Um sistema transpilado não pode tocar no Hub, em um banco de dados ou em qualquer recurso apenas-servidor. Essa restrição é o que garante que ele rode igual no navegador e no servidor.

ase-codegen --module ase-atmosphere

analyze
clean
structure
types
interfaces
components
transpile
sistemas de cliente
integrate
index

// Traga sua própria IA

Desenvolva na sua própria assinatura Claude. Vire uma chave para lançar.

O daemon Reasoning-Edge da ASE conduz a CLI que você já paga - então o pesado custo de iteração de construir um MMORPG movido a LLM permanece uma assinatura mensal fixa durante o desenvolvimento, não uma conta de API medida.

developmentedge_only sua assinatura de CLI · $0 de custo de operador

vire uma chave

um campo de manifesto

productioncloud_only backends de API limitados e auditáveis

edge-daemon

$ase edge run

O daemon de edge roda na sua máquina e gera a CLI instalada - claude, codex, gemini-cli, cursor-agent - como um processo filho, canalizando stdin/stdout. Ele não faz proxy de tokens OAuth e não manipula headers: tecnicamente indistinguível de você iniciar a CLI em um shell.

Sua CLI, como um subprocesso

lifecycle.phase

$ase ship --phase production

development usa por padrão edge_only (sua assinatura, zero custo de operador); production usa por padrão cloud_only (backends de API limitados). Virar a fase lança as mesmas skills sem mudança de código de skill - uma troca incompatível é bloqueada com uma lista de atualização de skills, não uma quebra silenciosa.

Uma chave para lançar

install.sh

$curl edge.ase.dev/install | sh

Um binário nativo menos de 50 MB para cinco plataformas, cada uma com um SBOM e uma assinatura ES256 YubiKey-PIV para verificação offline. Ele abre apenas uma conexão WSS de saída - sem porta de entrada, então funciona atrás de NAT e firewalls - e não guarda estado em repouso.

Instalação em uma linha

tos.check

$ase reasoning --tos-check

Reutilizar o token OAuth de uma assinatura dentro de um produto de terceiros é proibido; invocar a CLI oficial como um subprocesso é permitido. Como essa distinção é informal, um provedor re-fechando o modelo é absorvido por uma única troca de manifesto de edge para cloud-API - zero mudanças de código de skill.

Limpo em ToS & resiliente

backends

$ase edge backends

Quatro backends de CLI mais um custom_backend slot. Uma skill declara um work_type, nunca um nome de modelo - então trocar de provedor é uma mudança de config da engine sem edição de código de skill, e dev-vs-prod usam backends diferentes para a mesma skill.

Traga qualquer CLI

manifest.yaml

$ase edge init

O daemon lê ~/.ase-edge/manifest.yaml - qual CLI, qual projeto, qual token de conexão. Nenhum código de projeto vive no edge; ele apenas transforma o stdout da CLI em intents tipados que o World pode consumir.

Config, não código

connection

$ase edge status

Saída WSS apenas para o Replica, com heartbeat e reconexão automática. Sem porta de entrada significa que ele roda atrás de NAT, firewalls e wifi de café; um link caído se reconecta sem perder a sessão.

Apenas saída, seguro para NAT

vault.lease

$ase vault lease

Em produção, as chaves de LLM do cliente vivem em um Vault dedicado de 3 nós; o Reasoning nunca lê o Vault diretamente. Cada inferência busca um novo token de lease de 60 segundos via o Replica, máximo de 5 renovações - um processo comprometido só pode roubar um token que expira em segundos.

Leases de 60s, nunca hospedados

resolve

$ase reasoning --explain-resolve

Um resolvedor de backend de 7 passos determinístico mapeia o work_type de uma skill para um backend concreto e registra resolved_backend_id, backend_pool_version, was_fallback e was_degraded por chamada - toda inferência é auditável após o fato.

Determinístico + registrado

multi-edge

$ase edge lock

Vários daemons de edge podem se conectar a um projeto; um modo de lock arbitra qual daemon serve uma dada skill. Um dev solo em duas máquinas - ou uma equipe pequena - compartilha o reasoning de um projeto sem colisões.

Multi-edge, travado

local.first

$ase reasoning --local

A local_resolution bloco de manifesto permite ao passo-0 da resolução responder no edge com sem egress antes de qualquer backend de nuvem ser tocado. O caminho mais barato e mais privado é tentado primeiro por construção - não como uma reflexão tardia.

Caminho sem egress primeiro

audit

$ase reasoning consulta de auditoria --skill <id>

Toda inferência registra resolved_backend_id, was_fallback e was_degraded; a consulta de auditoria retorna o trace de qualquer skill em qualquer intervalo de datas. “Por que isto caiu no backend X?” tem uma resposta, após o fato.

Toda chamada é rastreável

dev.cost

$ase edge cost

Durante o desenvolvimento o custo de iteração é uma assinatura CLI fixa - seu próprio plano, pelo preço público de tabela (um plano Claude Max custa $200/mês), em vez de tokens medidos. A fase cara nunca é medida.

Fixo, não de quatro dígitos

auto.tune

$ase reasoning tune

Uma política de ajuste troca o backend ou a model-class de uma skill quando a telemetria ao vivo de custo-e-qualidade cruza um limite - orientada a dados, sem nomes de modelo hardcoded. Você define um alvo; o sistema encontra o backend mais barato que ainda o atende.

Controle de custo em malha fechada

fixo, não medido

Custo de desenvolvimento fixo, não uma fatura de API em aberto

Como os skills rodam contra sua própria assinatura CLI durante o desenvolvimento, o custo de iteração é o preço mensal fixo do seu plano - um plano Claude Max custa US$ 200/mês de tabela - em vez de tokens medidos. A produção então muda para cobrança de nuvem limitada e transparente, que paga apenas inferência real de jogadores.

2 camadas, nunca cruzadas

Duas camadas de custo que nunca se tocam

A Camada 1 (servidores, hospedagem MongoDB/Neo4j, skills internas da engine) é coberta pela assinatura fixa da ASE. A Camada 2 - a inferência de LLM que seu jogo gera - vai direto para a conta do seu próprio provedor e nunca passa pelo operador. O operador nunca subsidia seu custo de LLM e nunca hospeda seus tokens de assinatura.

// Skills como entidades ECS

Um skill é uma entidade, não um serviço - componha-os como blocos de montar.

Na ASE uma skill não é um arquivo markdown ou um microsserviço registrado. É uma entidade ECS nascida em runtime a partir de um manifesto declarativo e capturada por uma query - o mesmo princípio Tudo-Pode-Nada-Deve, estendido ao reasoning.

SkillManifest · uma skill é dado, não um serviço

id: lore-consistency-checker
subscriptions: [ DialogueIntent, LoreState ]
reads:  [ CharacterMemory, WorldFacts ]
writes: [ AnomalyIntent ]        # nada fora disto é permitido
work_type: reasoning_heavy      # uma necessidade, não um nome de modelo
cost_layer: game
communication_pattern: standard
memory: [ episodic, semantic, procedural ]
quota: { usd, rate, concurrency, … }  # 10 eixos, verificados antes do gasto

Anexe um componente → a skill está ativa.
Duas skills em componentes sobrepostos → reasoning emergente, sem orquestração.

11 grupos de campos do manifesto · 9 work_types · 0 serviços de registro

Anexe um componente, a skill está ativa

0 serviços de registro

Um projeto anexa componentes SkillManifest às entidades certas; o Reasoning Tier os captura através de registry.view<SkillManifest, SkillSubscriptions>. Sem serviço de skill-registry, sem padrão de loading, sem endpoint de setup por projeto - a lógica de composição vive na query, não em uma camada de orquestração.

Uma entidade de skill, todo projeto correspondente

1 entidade · N projetos

Uma única skill escrita centralmente - digamos um verificador de consistência de lore - vive uma vez como uma entidade e atravessa o grafo compartilhado V-3-Verbund através das fronteiras de projeto, sem instalação por projeto. Dois projetos com assinaturas sobrepostas obtêm reasoning emergente sobreposto sem saber um do outro.

Uma skill fisicamente não pode escrever fora da sua lane

11 grupos de campos do manifesto

O manifesto é a única autoridade sobre o comportamento de uma skill. Se uma skill - por um bug, prompt injection ou deriva de LLM - emite um tipo de intent que não declarou, a escrita é rejeitada e registrada como uma violação de lane. A lista de reads é igualmente estrita - um componente não declarado não pode nem entrar no prompt, uma linha de privacidade-padrão sob GDPR/LGPD.

Declare o que você precisa, não qual modelo

9 work_types · resolução de 7 passos

Uma skill declara um work_type como reasoning_heavy, não um nome de modelo. Trocar de provedor é uma mudança de config da engine sem edição de código de skill, resolvida deterministicamente em sete passos e totalmente registrada - resolved_backend_id, was_fallback, was_degraded e um trace completo gravado por inferência.

Reasoning nunca escreve o estado diretamente

source:skill vs source:player

As saídas de skills são registradas como componentes *Intent marcados com source:skill; as entradas de jogador como *Intent marcados com source:player; o World consome ambos de forma idêntica. Essa única regra de lane é o que mantém um mundo ASE reproduzível apenas a partir das entradas - um replay pode reutilizar intents registrados ou re-executar um novo reasoning.

Memória modelada na cognição humana

9 coleções

A memória de skill são nove coleções MongoDB seguindo a classificação Tulving/Squire - episódica, semântica, procedural, relacional - com índices vetoriais nas três semânticas. O Replica possui todas as nove; o Reasoning nunca toca no MongoDB. A memória do jogador fica em uma cascata de deleção GDPR/LGPD conduzida por um único ase player forget.

Tudo-Pode-Nada-Deve, para o reasoning

componha por anexação

O princípio que rege as entidades do mundo rege as skills também: uma skill PODE se inscrever em qualquer coisa que declara e NÃO DEVE fazer nada implicitamente. O comportamento é composto anexando um componente, nunca conectado por um coordenador - reasoning é apenas mais ECS.

Duas skills, reasoning emergente

emergent

Dois skills inscritos em components sobrepostos produzem comportamento combinado que nenhum declara sozinho. Essa é a promessa da composição: nenhum código de orquestração, nenhuma integração - a composição é emergente, exatamente como a simulação abaixo.

A cota controla toda chamada, antes do gasto

10 eixos · pré-gasto

Dez eixos de cota ortogonais são verificados antes de uma inferência rodar. Em um limite rígido, a chamada nunca é emitida - um QuotaExceededIntent é escrito em vez disso - então uma skill com prompt injection ou descontrolada não pode acumular custo, porque o gasto nunca começa.

communication_pattern escolhe a lane

4 lanes

O communication_pattern de uma skill - standard, anti_cheat_lane, reasoning_pipeline ou engine_internal_bus - a roteia para a lane certa com seus próprios limites e profundidade de escalonamento. Declarado uma vez no manifesto, imposto pela engine.

Anti-cheat é apenas mais uma skill

lane de anti-cheat

A detecção de anomalias comportamentais é entregue como skills em uma lane de anti-cheat dedicada com limites de escalonamento mais profundos e uma cota de jogador invertida - quanto mais anômalo o comportamento, mais análise ele recebe. O mesmo modelo de entidade, economia invertida.

Credenciais que a skill nunca vê

lease de 60s

As chaves de LLM do cliente nunca chegam a uma skill. O Reasoning busca um novo token de lease de 60 segundos via o Replica para cada inferência (máx. 5 renovações); a uma skill é entregue uma capacidade, não um segredo - e um processo comprometido só pode roubar algo que expira em segundos.

Nasce em runtime, some ao ser desanexada

ciclo de vida = entidade

O ciclo de vida de uma skill é o ciclo de vida de uma entidade: ela ganha vida no momento em que seu componente de manifesto é anexado e para no momento em que é removido. Sem passo de deploy, sem registro, sem script de teardown - criar e destruir é toda a história de instalação.

Reasoning é um tier, não um chatbot

4º plano de processo

O Reasoning Tier é seu próprio plano de processo escalável horizontalmente ao lado de Engine, Replica e World - não uma chamada de API parafusada em um render loop. O trabalho baseado em linguagem vive onde pode ser escalado, ter cota e ser auditado em seus próprios termos.

Duas camadas de custo, por skill

cost_layer

Um campo cost_layer decide quem paga: skills internas da engine viajam na assinatura fixa da ASE; skills que chamam o seu próprio modelo faturam direto ao seu provedor. O operador nunca subsidia sua inferência e nunca adianta seus tokens.

O World não distingue skill de jogador

ambos são *Intent

As saídas de skills e as entradas de jogador ambas chegam como componentes *Intent; o World as aplica pelas mesmas regras e nunca ramifica com base na sua origem. Essa simetria é exatamente o que permite a um tier não-determinístico ficar sobre uma simulação determinística.

Busca vetorial em três de nove

memória semântica

Das nove coleções de memória, as três semânticas carregam índices vetoriais para recuperação por similaridade; a memória episódica e a procedural permanecem em correspondência exata. O Reasoning guarda apenas ponteiros de referência ECS para elas - o Replica possui o armazenamento.

Um comando apaga um jogador

ase player forget

A eliminação do titular dos dados é um único comando de operador: ase player forget faz cascatear uma deleção GDPR/LGPD por todas as nove coleções de memória de uma vez. Privacidade é uma operação embutida, não uma varredura manual pelos armazenamentos.

Toda inferência deixa um rastro

totalmente auditável

resolved_backend_id, backend_pool_version, was_fallback, was_degraded e um trace completo de resolução são registrados por chamada. Qual modelo respondeu, se houve fallback e se houve degradação é reconstrutível após o fato para qualquer inferência.

Skills ociosas não custam nada

inscreva-se, não faça polling

As skills reagem a mudanças de componentes através de assinaturas, não de um loop de polling. Uma skill sem nada a que reagir não emite inferência e não gasta nada - atenção, e custo, seguem onde a simulação de fato muda.

Pergunte por que uma skill escolheu um backend

consulta de auditoria

ase reasoning consulta de auditoria --skill <id> retorna os traces de resolução de qualquer skill em qualquer intervalo de datas. “Por que esta skill caiu no backend X?” tem uma resposta concreta, após o fato, não um dar de ombros.

Três padrões de fluxo, só isso

3 padrões

Toda interação do Reasoning Tier se reduz a três padrões de fluxo nomeados. Módulos do domínio de reasoning e plugins de LLM os implementam; planos de fase referenciam o padrão pelo nome em vez de re-coreografá-lo. A camada de cognição tem uma gramática.

Skills que se auto-ajustam

malha fechada

Uma política de ajuste pode trocar a model-class ou o backend de uma skill, ou fixar uma versão de manifesto diferente, quando a telemetria ao vivo de custo-e-qualidade cruza um limite - orientada a dados, sem nomes de modelo hardcoded e sem casos especiais por skill. O sistema se ajusta sozinho.

Responda localmente primeiro

local_resolution

A local_resolution bloco de manifesto faz o passo-0 da resolução perguntar “isto pode ser respondido no edge, sem egress?” antes de qualquer chamada de nuvem ser considerada. Cognição barata, privada e local é tentada primeiro - a pedra angular econômica do reasoning em escala planetária.

O barramento interno da engine é lacrado

lane-enforced

Uma skill com cost_layer engine carrega um marcador de lane que roteia sua saída apenas para outras skills de custo-engine, nunca para skills de cliente - imposto no nível do fio na decodificação do Replica. A cognição interna não pode vazar para uma lane de cliente.

// Custo previsível

Em um limite rígido, a inferência nunca começa - então o custo não pode derivar.

O Reasoning Tier controla toda chamada de LLM por trás de dez eixos de cota ortogonais. Uma skill com prompt injection ou descontrolada não pode acumular uma conta, porque o gasto nunca começa. Limites amigáveis a indies são uma propriedade da arquitetura, não uma promessa.

eixo 01Custo USD

eixo 02Slots de rate-limit

eixo 03Armazenamento de memória

eixo 04Concorrência

eixo 05Spam de jogador

eixo 06Profundidade de escalonamento

eixo 07Leituras entre projetos

eixo 08Assinatura de edge

eixo 09Raio de impacto / skill

eixo 10Raio de impacto / projeto

uma requisição de inferência → todos os 10 eixos verificados antes de qualquer gasto → passa · a chamada roda falha · nunca emitida → QuotaExceededIntent

Limite rígido = inferência não iniciadao gasto nunca começa

Em um limite rígido, a chamada não é limitada, ela nunca é emitida - um QuotaExceededIntent é escrito em vez disso. Uma skill com prompt injection ou descontrolada não pode acumular custo, porque a inferência não começa de forma alguma.

Transparência total de token e USD, por inferênciadashboard por skill

Toda chamada registra resolved_backend_id, backend_pool_version, was_fallback, was_degraded e um trace completo de resolução. O dashboard do cliente agrega o custo-por-skill detalhado por backend, taxa de fallback e taxa de degradação - você lê a conta linha por linha.

Duas camadas de custo, nunca cruzadas2 camadas

O custo de infraestrutura do operador e o custo de inferência de LLM são separados estruturalmente. O operador nunca subsidia o gasto de LLM do cliente e nunca hospeda os tokens de assinatura do cliente - então as duas contas não podem contaminar uma à outra.

Dez eixos de cota ortogonais10 eixos

Custo USD, slots de rate-limit, armazenamento de memória, concorrência, spam de jogador, profundidade de escalonamento, leituras entre projetos, assinatura de edge e dois eixos de raio de impacto - todos os dez devem ser satisfeitos antes de uma única inferência rodar.

Limitado por skill, jogador, projeto, backendlimitado de quatro formas

Todo eixo é imposto por skill, por jogador, por projeto e por backend, então nenhuma dimensão isolada pode se descontrolar. Limites previsíveis são uma propriedade da arquitetura, não uma promessa impressa em uma página de preços.

O cap para o gasto, não a faturaby design

Quando um limite é atingido, a inferência nem chega a ser iniciada - deriva de custo é estruturalmente impossível. Como os caps são declarativos, a fatura é limitada antes do lançamento, não conciliada em choque depois.

Desenvolva em uma assinatura, lance com limitesedge → cloud

O desenvolvimento roda edge_only na sua própria assinatura de CLI fixa; a produção vira para um faturamento de nuvem limitado e auditável. A fase cara de iteração nunca toca em tokens medidos - a disciplina de custo é imposta antes de o dinheiro ser gasto.

Consulte a conta por skillconsulta de auditoria

ase reasoning consulta de auditoria --skill <id> retorna os traces de resolução por trás do gasto de uma skill em qualquer intervalo de datas. A conta não é uma caixa-preta - você pode perguntar qual backend respondeu, com que frequência houve fallback e quanto custou.

cost_layer decide quem pagaengine / game

O cost_layer de uma skill é ou engine (viajando na assinatura fixa da ASE) ou game (faturado ao seu próprio provedor). O eixo de faturamento é declarado no manifesto, então quem paga por uma inferência nunca é uma surpresa descoberta em uma fatura.

Caminho mais barato primeiro: resolução localsem egress

O passo-0 da resolução pergunta se uma chamada pode ser respondida localmente no edge sem egress algum, antes de qualquer backend de nuvem pago ser considerado. O caminho de custo-zero é tentado primeiro por construção - a pedra angular econômica de escalar a cognição.

A cota persiste sem uma pontefire-and-forget

O Reasoning tier envia incrementos de cota fire-and-forget para o Replica, que os persiste em um estado de cota dedicado - sem serviço de ponte extra, sem escrita síncrona no hot path. A contabilidade nunca atrasa uma inferência.

O sistema ajusta em direção a um alvoqualidade mín. @ custo máx.

Uma política de auto-ajuste expressa um alvo - qualidade mínima aceitável a um custo máximo - e troca o backend ou a model-class de uma skill quando a telemetria ao vivo cruza o limite. Custo/qualidade é um botão que você ajusta, não uma conta que você audita depois.

Custo marginal fixo por projeto1001 ≈ 1000

Os projetos compartilham um substrato - um grafo, um namespace Hub/Almanach - então o custo do milésimo-primeiro projeto é cerca do custo do milésimo. Não há banco de dados ou compute por projeto para provisionar, e nenhum precipício de custo por projeto.

Traga sua própria IA durante o desenvolvimentoedge_only

Itere contra a sua própria assinatura de CLI enquanto você constrói; a produção vira para um faturamento de nuvem limitado com uma troca de manifesto. A fase em que você queima mais inferência - o desenvolvimento - nunca toca em tokens medidos.

Custo é um campo de manifesto, não um mistériodeclared

Cota, cost_layer e model-class são declarados por skill no manifesto. O gasto é projetado de antemão - você pode ler o perfil de custo de uma skill antes de ela rodar, em vez de descobri-lo na fatura do mês seguinte.

Escalonamento e raio de impacto são limitadosalcance limitado

Dois dos dez eixos de cota limitam até onde uma única skill pode escalar e quão amplo seu efeito pode alcançar. Uma skill descontrolada ou com prompt injection não pode se encadear em um gasto ilimitado - o alcance é limitado, não apenas o custo por chamada.

Preços amigáveis a indies com limites previsíveis. Traga sua própria IA durante o desenvolvimento.

✓ Limites previsíveis - sem descontrole medido, sem faturas surpresa

✓ Desenvolva na sua própria assinatura de IA, lance com faturamento de nuvem limitado

✓ Disciplina de custo imposta antes de o dinheiro ser gasto, não reconciliada depois

// Anti-cheat como reasoning de primeira classe

Reasoning detecta, World coloca em quarentena, Engine sanciona - um humano assina o banimento.

Anti-cheat é um caso de uso de reasoning embutido com uma hierarquia de autoridade de três tiers que escala em irreversibilidade - e nunca chega a deixar um LLM banir um jogador por conta própria.

// por que desde a hora um, não após o lançamento

Todo MMO morre das mesmas feridas: farming de bots, speed hacks, griefing coordenado, inflação descontrolada - e no final ficam os wipes e o êxodo de jogadores. Três décadas de história de MMO ensinam a mesma lição, e fiscalização acrescentada depois do lançamento chega tarde demais: a economia já está envenenada. ASE puxa essa lição para a arquitetura desde a hora um: detecção, quarentena e sanções assinadas por humanos são primitivas da engine, não um patch pós-lançamento.

reversibleAnomalyIntentReasoning detecta

→

reversibleQuarantineStateWorld coloca em quarentena

→

irreversiblePlayerSanctionStateEngine sanciona · um humano assina

Três tiers de autoridade, irreversibilidade crescente

3 tiers

Reasoning escreve um reversível AnomalyIntent (score + categoria + ponteiro de evidência). O World os acumula deterministicamente em um reversível QuarantineState. Apenas o Engine escreve o irreversível PlayerSanctionState - que requer um human_reviewer_id e uma trilha de auditoria. O recommended_action de uma skill pode ser monitor, quarantine ou review, mas nunca ban.

Uma suíte de detectores que você habilita por projeto

4 detectores

O design inclui detectores de custo-engine que qualquer projeto pode habilitar: BehaviorWatcher (anomalias comportamentais), CoordinationDetector (padrões multi-conta), EconomyAuditor (exploits econômicos) e MovementValidator (speed-hack/teleport, aumentado por reasoning sobre a verificação-rápida determinística do World).

Jogadores suspeitos são vigiados mais, não menos

cota invertida

As skills de anti-cheat carregam uma cota de jogador invertida - quanto mais anômalo o comportamento, mais análise ele recebe - e rodam em uma lane de comunicação dedicada com limites de escalonamento mais profundos. A economia é invertida de propósito.

O determinismo sobrevive a um tier não-determinístico

replayable

Como o reasoning só escreve intents, nunca estado simulativo, um mundo ASE permanece reproduzível apenas a partir das entradas. Um replay pode reutilizar skill-intents registrados para uma reprodução perfeita ou emitir novas chamadas de reasoning para uma re-geração não-determinística - sua escolha, só possível por causa da regra de lane.

Suas chaves de API: armazenadas, nunca vistas

Leases de 60s · máx. 5 renovações

As credenciais de LLM do cliente vivem em um cluster Vault dedicado de 3 nós (Raft, auto-unseal), separadas das credenciais da engine no nível de armazenamento. A identidade do operador não tem política de leitura nos caminhos do cliente, e o Reasoning não tem acesso direto ao Vault - cada inferência busca um novo token de lease de 60 segundos, máx. 5 renovações, mediado pelo Replica. Um processo de reasoning comprometido só pode roubar tokens de vida curta que rapidamente se tornam inúteis.

Um humano assina cada banimento

human-in-loop

A sanção irreversível só pode ser escrita pelo Engine e requer um human_reviewer_id mais uma trilha de auditoria. Um LLM pode recomendar monitor, quarantine ou review - ele nunca pode banir um jogador por conta própria. A automação escala; uma pessoa decide.

Verificação-rápida determinística, verificação-lenta semântica

rápido → profundo

MovementValidator roda uma checagem determinística de speed/teleporte direto na World; detecção de padrões com reasoning adiciona depois o contexto semântico. Duas velocidades, um veredito - certeza barata primeiro, nuance cara depois.

A quarentena é reversível, a sanção não

reversível → final

QuarantineState acumula deterministicamente a partir de AnomalyIntents e pode ser suspenso; apenas a sanção final é permanente. O escalonamento sempre corre do reversível para o irreversível, nunca o contrário - um falso positivo custa uma quarentena suspensa, não um banimento indevido.

Conluio entre contas

multi-account

O CoordinationDetector procura padrões que uma única verificação determinística não consegue ver - timing sincronizado, fluxos de economia e correlação de movimento entre contas - como uma skill de reconhecimento de padrões de LLM. Contexto é exatamente o que falta ao anti-cheat determinístico.

Auditoria de economia, embutida

economy

O EconomyAuditor vigia loops de duplicação, manipulação de mercado e curvas de riqueza impossíveis como uma skill de custo-engine que qualquer projeto liga - não um serviço que você integra. A economia é simulada, então seus exploits são legíveis.

Ponteiro de evidência, não um dump bruto

auditable

Um AnomalyIntent carrega um score, uma categoria e um ponteiro de evidência - o reasoning referencia o estado ECS, ele não o copia. A trilha de auditoria permanece enxuta, o World permanece autoritativo, e toda decisão é reproduzível a partir das mesmas entradas.

Sem driver de kernel, sem escaneamento de cliente

apenas no lado do servidor

A detecção é comportamental e vive no servidor - a ASE não entrega nenhum driver de kernel de anti-cheat e não escaneia a memória de nenhum jogador. A trapaça é pega pelo que um jogador faz na simulação - não vigiando a máquina dele.

Autoritativo no servidor por construção

O World possui o estado

O World mantém o estado autoritativo; o input do cliente chega pelo canal não-confiável e é validado no lado do servidor. Um cliente hackeado pode requisitar, mas não pode afirmar - ele nunca consegue escrever um estado que a simulação não computou.

Anomalia comportamental, não uma lista de regras

exploits inéditos

O BehaviorWatcher sinaliza anomalias estatísticas através de reconhecimento de padrões de LLM, então ele pega exploits inéditos que uma lista fixa de regras nunca viu. O detector raciocina sobre o comportamento em vez de casar com uma assinatura que os atacantes já conhecem.

A profundidade de escalonamento é um eixo limitado

quota-bounded

Até onde uma skill de anti-cheat pode escalar é um dos dez eixos de cota - com um limite deliberadamente mais alto na lane de anti-cheat. Até os vigias rodam dentro do mesmo modelo de custo limitado e auditável que todo o resto.

O escrutínio escala horizontalmente

mais compute, não um gargalo

O anti-cheat roda como skills de reasoning em seu próprio tier escalável horizontalmente, então vigiar um jogador suspeito com mais afinco é mais compute - nunca um travamento no game loop. A aplicação pode crescer sem a simulação pagar por isso.

Uma trilha de auditoria imutável

append-only

Toda sanção registra o human_reviewer_id, o ponteiro de evidência e um timestamp em uma trilha somente-anexação. Um recurso reproduz o registro exato que levou à decisão - não um resumo escrito após o fato.

O intent é score, categoria, evidência

reporta, não decide

Um AnomalyIntent carrega apenas um score numérico, uma categoria e um ponteiro para o estado ECS que o disparou. Ele reporta; o World decide o que acumular e o Engine decide se um humano chega a vê-lo.

A vigilância roda em cota medida

escrutínio limitado

A inferência de anti-cheat tem cota como qualquer outra skill - score, taxa e profundidade de escalonamento são todos limitados. O escrutínio tem um custo limitado e auditável, então o lado da aplicação não pode se descontrolar mais do que o lado do jogo.

A detecção melhora sem um patch

manifesto, não release

Como o BehaviorWatcher raciocina sobre o comportamento em vez de casar com uma lista fixa de regras, ensiná-lo um novo padrão de exploit é uma mudança de manifesto e prompt - não um release da engine. Os vigias aprendem mais rápido que um ciclo de patch.

Um falso positivo é barato

reversível por design

Como tudo abaixo da sanção final é reversível, uma sinalização errada custa uma quarentena suspensa, não um banimento indevido. O escalonamento é construído para que o erro caro - uma sanção permanente ruim - seja o único que um humano tem que assinar.

// Mundos que você pode construir

Aetheria: 9.000 planetas procedurais que colapsam em um único mundo compartilhado.

Isso não são recursos do ASE - são mundos construídos COM ele. Aetheria é a prova tomando forma. Mítico na superfície, mecânico por baixo.

9,000→1

A reencarnação colapsa o multiverso - uma alma se liga à carne, todo caminho não tomado deixa de existir, e um único mundo compartilhado e irreversível permanece.

9.000 planetas · 6 fases

9.000 planetas, não 9.000 shards

Aetheria gera 9.000 planetas procedurais que são locais de nascimento, não servidores paralelos. Cada um imprime um personagem através de seis fases - genética, físico, vocação, teologia, psique, transcendência - então a variedade procedural se torna a diversidade cultural, genética e espiritual de um único mundo compartilhado.

9.000 → 1

A reencarnação colapsa o multiverso

Uma alma se move como uma superposição por futuros não escolhidos; toda decisão gera um ramo, todo genoma descartado colapsa de vez. No instante em que se liga à carne, todos os 9.000 planetas e todo caminho não tomado deixam de existir - uma única realidade compartilhada e irreversível, persistida em MongoDB e Neo4j.

5% / 10% / 15% / >15%

Um mundo com um sistema imunológico

Antarien não é um corpo, mas um organismo - Mater Dormiens, a mãe adormecida. Um índice de ferida orientado a dados atrelado à mineração escala: abaixo de 5% ela dorme; 5–10% os sulcos cicatrizam e as ferramentas corroem; 10–15% traz tremores, anomalias gravitacionais e gás tóxico; acima de 15% os caminhos nervosos sob o leito do oceano pulsam e brilham conforme ela acorda.

1 universo

Um organismo, dois jogos, sem shards

A Convergência entrega um personagem da prequela Aetheria para o mundo persistente Antares Open World através de um handoff no lado do servidor - um universo global, todo jogador, sem instâncias. O dataset completo (seed, bioma, genética, teologia, psique) se torna permanente e irreversível.

5 personagens

Cinco almas, um jogador

Cada jogador opera cinco câmaras de ressonância - cinco personagens, cinco reivindicações, cinco zonas de início, todas vivas ao mesmo tempo. Você conduz um; os outros quatro rodam movidos por IA, com um salto-de-alma para alternar entre eles. Uma ponte de inteligência de enxame de vaga-lumes atravessa entre seus próprios personagens ao longo da rede Cruor.

o paradoxo da pirâmide

O conhecimento da prequela se torna uma bússola

Na reencarnação, a memória consciente se perde, mas o corpo mantém tudo - genética, vocação como memória muscular, predisposições de cor-de-alma. O jogador sabe o que o personagem não pode: as “pedras sagradas” são sangue coagulado, os “terremotos” são uma criatura se virando, os santuários são os pontos mais finos na pele que respira.

construído às claras

O mundo de referência, em números

153 componentes · 86 sistemas (zero violações), 13 submódulos web - a vitrine que diz que você pode construir um jogo de verdade com isto, amadurecendo diariamente.

6 fases

Uma pessoa, não um spawn

Genética, físico, vocação, teologia, psique, transcendência - cada fase carimba o personagem, transformando um planeta procedural em uma pessoa com um corpo, uma cultura, uma fé e um destino. A diversidade é impressa, não decorada.

nave = cometa

A nave de geração é um cometa

O vaso que carrega almas entre mundos se lê, de fora, como um cometa - o mesmo objeto é ao mesmo tempo o mito no céu noturno e o mecanismo da Convergência. Nada no mundo é apenas decoração.

72 / 1,789 / 1,794

Lore engenhado, não improvisado

O mundo é modelado como um grafo de design Neo4j - 72 módulos, 1.789 casos de uso, 1.794 atores - antes de uma linha dele ser jogada. A história tem uma arquitetura, do mesmo jeito que a engine tem.

46.730 estrelas

Um céu noturno real

O mapa estelar são 46,730 corpos reais do banco de dados HYG - o céu acima de Aetheria é o catálogo real, navegável e consistente, não um pano de fundo pintado por trás da ação.

soul-jump

Cinco vidas, sem logout

Você conduz um de cinco personagens; os outros quatro continuam vivendo movidos por IA. Um salto-de-alma move sua atenção entre eles ao longo da rede Cruor - cinco reivindicações, cinco zonas de início, uma presença contínua no mundo.

a rede Cruor

Uma ponte de vaga-lumes entre almas

Uma ponte de inteligência de enxame de vaga-lumes atravessa entre seus próprios personagens ao longo da rede Cruor. Mover-se entre suas cinco vidas não é um toggle de menu - é uma jornada através de um sistema vivo que os conecta.

prequela → persistente

Aetheria forja, Antares guarda

Aetheria é a prequela onde uma alma é forjada através das seis fases; Antares Open World é o mundo persistente onde ela então vive. Dois jogos, um universo contínuo - a Convergência é a costura entre eles.

MongoDB + Neo4j

Realidade ligada, registrada

No instante em que uma alma se liga à carne, o dataset completo - seed, bioma, genética, teologia, psique - persiste em MongoDB e Neo4j como fato permanente e irreversível. O lore não é narrado; ele é armazenado.

// A parede de módulos

Oitenta e três módulos de simulação L3, conectados através de um Hub.

A engine não é um monólito - é uma estrela de módulos L3 independentes que escrevem saídas e leem uns aos outros através de um Communication Hub, com zero acoplamento direto. Todo módulo L3 na árvore abaixo - cada um seu próprio marcador, com sua maturidade real.

// Arquitetura em camadas

Seis camadas. As dependências só apontam para baixo.

A ASE é construída em camadas estritas, L0 a L5 - e a linha entre engine e jogo passa bem no meio delas. Os desenvolvedores da engine são donos de L0–L3; você constrói seu jogo em L4 e L5, e não vê nada além do header ase-sdk.

L0Fundação

L1Núcleo

L2Kernel

L3Módulos

L4Plugins

L5Servidores & Clientes

▸ Toda camada depende apenas para baixo. Sem exceções.

L0

Fundação

ase-math · ase-types · ase-utils · ase-containers · ase-json

Vetor, matriz, ruído e interpolação sem dependências. Deliberadamente puro - sem ECS - para que nada possa vazar para baixo. Todo sistema de simulação acima dele computa sobre esse alicerce.

L1

Núcleo

ase-ecs · ase-log · ase-neo4j · ase-mongodb

O ECS que envolve o EnTT, o logging e os clientes Neo4j e MongoDB. O Neo4j guarda relações e hierarquias; o MongoDB guarda chunks, estado e snapshots.

L2

Kernel

ase-kernel

O batimento: game loop, carregador de módulos via dlopen e o scheduler em camadas próprio - 66 schedules em 21 camadas, um scheduler de desenho próprio, de init once-per-life a frames de 60 Hz.

L3

Módulos · 83 deles

ase-hub · ase-weather · ase-replication · ase-foodchain · ase-perception …

A própria engine - os módulos de simulação, conectados através da topologia estelar do ase-hub sem acoplamento direto módulo-a-módulo. É aqui que bilhões de entidades ganham seu comportamento.

L4

Plugins · 27 deles

ase-pl-erosion · ase-pl-sky · ase-pl-water · ase-pl-flora …

Bibliotecas compartilhadas carregáveis a quente que o kernel descobre, verifica a versão de API e carrega via dlopen. Plugins ausentes degradam graciosamente - o servidor roda bem sem o plugin de clima - então os jogos compõem exatamente os sistemas de que precisam.

L5

Servidores & Clientes

ase-server-world · ase-server-replica · ase-client-web

Os servidores de quatro tiers e o cliente de navegador. O servidor World é o processo de compute onde física, ecologia e clima de fato dão tick; o cliente web roda becsy com paridade estrita 1:1 com o backend C++.

A fronteira engine / jogo2 camadas, 1 header

Os desenvolvedores da engine são donos da Fundação até os Módulos; os desenvolvedores de jogos constroem apenas plugins L4 e servidores/clientes L5, por trás do único header ase-sdk. Essa encapsulação é como uma pessoa constrói um MMORPG com a engine em vez de uma engine.

O mesmo ECS, ambos os lados do fioparidade 1:1

EnTT no servidor C++, becsy no navegador - view<A,B>() mapeia para query, on_construct para added - então componentes SHARED mantêm paridade estrita 1:1. Um sistema SHARED recalcula deterministicamente, colapsando ~100 B × 20 Hz de broadcast para ~4 B × 1 Hz: envie a semente, não o resultado.

As dependências apontam apenas para baixoL0 ← L5, uma direção

L5 para L0, estritamente: uma camada mais alta pode alcançar para baixo, nunca para cima ou para os lados. A Fundação L0 (math, types, utils) tem zero dependência de ECS, então nada pode vazar para cima no alicerce sobre o qual toda a simulação computa.

L2 Kernel: o batimento cardíaco66 schedules · 21 tiers

O kernel roda o game loop, o carregador de módulos dlopen e um scheduler em camadas customizado - 66 schedules nomeados ao longo de 21 tiers, de init once-per-life a frames de 60 Hz. Um scheduler de desenho próprio; tudo acima bate por causa dele.

L1 Núcleo: ECS mais os clientes de BDNeo4j + MongoDB

O ECS que envolve o EnTT, o logging e os clientes Neo4j (relações, hierarquias) e MongoDB (chunks, estado, snapshots) - a camada quente de tempo real mais a persistência do plano de dados, mantida um nível abaixo dos módulos.

Plugins L4 carregam a quente e degradamhot-loadable

Plugins são bibliotecas compartilhadas carregadas via dlopen com verificações de versão de API; um plugin ausente degrada graciosamente - o servidor roda bem sem o plugin de clima - então um jogo compõe exatamente os sistemas de que precisa, nada além.

L3 é a própria engine83 módulos

Oitenta e três módulos de simulação conectados através da topologia estelar do ase-hub sem acoplamento direto módulo-a-módulo - esta é a camada onde bilhões de entidades ganham seu comportamento, e onde uma nova causalidade custa um campo de componente.

A Fundação L0 não tem ECSalicerce puro

Math, types e utils ficam na base e não dependem de nada acima deles - nem mesmo do ECS. O alicerce sobre o qual toda a simulação computa permanece livre de acoplamento com a engine, então nada pode vazar para baixo nele.

A camada de integração é o main.cppuma exceção

Os sistemas nunca chamam uns aos outros - a única exceção sancionada são os handlers HTTP no main do servidor, a camada de integração. Em todo o resto, a lógica fala apenas através de componentes, que é o que mantém a coisa toda componível.

L5: os servidores e clientes que você lançaR3F + becsy

No topo, ase-server-game roda o mundo e ase-client-web o renderiza no navegador com React-Three-Fiber sobre um ECS becsy. Ambos são L5, construídos sobre tudo abaixo - as únicas camadas que a maioria dos devs de jogos chega a tocar.

// Para quem é

A engine para MMORPGs nativos de IA. Para todo o resto, ainda há a Unreal.

A ASE é fortemente direcionada, e vale ser honesto sobre quem deveria construir sobre ela hoje - e quem não deveria. Complementar por design, não competitiva.

Para o construtor solo de um mundo vivo

2 camadas, 1 header

Se você quer construir um MMORPG movido a LLM como uma pessoa - projetá-lo em uma bancada e ficar do lado de fora dele como criador - a ASE foi construída para exatamente isso. Devs de jogos tocam duas camadas e um header; anexe os componentes que quiser e a cascata completa de simulação vem de graça onde quer que você tenha anexado algo.

Para simulação em escala planetária além dos jogos

7+ domínios

Como a ASE simula sistemas causais reais em vez de renderizar cenário, o mesmo substrato mira pesquisa climática (ciclos de CO² e temperatura), ecologia (espécies invasoras, extinção), planejamento urbano, geologia ao longo de milhões de anos, evolução e dinâmica populacional, educação e arte generativa.

Para equipes que querem nativo de LLM, não parafusado

Um Reasoning Tier dedicado, skills como entidades ECS, economia BYO-AI e anti-cheat como um caso de uso de primeira classe - reasoning é um plano de processo na arquitetura, não um chatbot grampeado ao lado de um render loop.

Não para o seu próximo FPS fotorrealista

A ASE otimiza para significado simulado e escala planetária, não para o render de mais alta fidelidade de um pequeno nível feito à mão. Essa é uma fronteira deliberada: para MMORPGs nativos de IA, construa com a ASE; para todo o resto, ainda há a Unreal.

Honesto sobre onde ela está

beta fechado a caminho

A ASE é construída às claras e amadurece diariamente. A arquitetura e a visão estão bem pensadas, a implementação está em andamento, e um beta fechado está a caminho. Sem alegações de “finalizado” - a escada de build-status ao vivo acima mostra a maturidade real de cada módulo, de seed a refine.

Para o pessoal dos AI-builders

Nativo de IA

Se você pensa em IA agêntica, tool-use e skills-como-primeira-classe, a ASE aplica essa filosofia a mundos: skills são entidades ECS, reasoning é um tier federado com um daemon de edge. Polinização cruzada entre IA e game-dev, não uma virada de gênero.

Para pesquisa climática & de sistemas terrestres

climate

Ciclos de CO² e temperatura, hidrologia, erosão ao longo do tempo profundo - a mesma simulação em camadas GIS que roda um mundo de jogo roda um planeta que você pode estudar. A saída é dado, não apenas cenário.

Para ecologia & evolução

ecology

Espécies invasoras, cascatas de extinção, seleção natural e dinâmica populacional emergem da simulação entidade-por-organismo - um laboratório onde os mecanismos são legíveis porque todo organismo é uma entidade de primeira classe, não uma tabela de spawn.

Não para um platformer de hobby

poder, não paparico

Se você quer um tutorial de construa-seu-primeiro-jogo-em-30-minutos, Unity ou Godot se encaixam melhor. A ASE troca paparico por poder - é para as pessoas que as ferramentas amigáveis geralmente seguram, não para o caminho amigável em si.

Não para um jogo de história single-player

complementary

Para uma narrativa single-player feita à mão, a Unreal é o melhor lar. A ASE é para mundos vivos, movidos a LLM e persistentes - um problema diferente, resolvido de forma diferente, e deliberadamente não a engine de todo mundo.

Para planejamento urbano & logística

cities

Tráfego, cadeias de suprimento, fluxo populacional e estresse de infraestrutura se modelam naturalmente como agentes em um mundo em camadas GIS. O mesmo substrato que roda uma cidade em um jogo roda uma cidade que você quer estudar - todo veículo e residente uma entidade de primeira classe.

Para geologia ao longo do tempo profundo

tempo profundo

Erosão, sedimentação e mudança tectônica ao longo de milhões de anos simulados caem da mesma arquitetura de scheduler em camadas que faz vida rápida e pedra lenta baterem em cadências separadas. Escala de tempo é uma camada de schedule, não um modo especial.

Para arte generativa & instalações

uma tela viva

Um mundo que roda sobre causa-e-efeito real é um instrumento generativo: semeie-o, deixe a simulação respirar, e a saída é emergente em vez de autorada. A simulação é o conteúdo - uma tela que continua se pintando.

Para pesquisadores de IA & multiagente

emergência em escala

Vastas populações de agentes com percepção, memória e reasoning reais fazem do ASE um laboratório para dinâmica multiagente emergente - não um grid-world de brinquedo. Comportamento se compõe de components - novos experimentos são novos dados, não novas engines.

Para o metagamer systems-first

profundidade sobre polimento

Se você ama sistemas profundamente interligados - a linhagem EVE, Dwarf Fortress, Rimworld - a ASE foi construída para esse instinto: tudo é simulado, tudo está conectado, e a profundidade é o ponto, não uma configuração de dificuldade.

Para educação, como um instrumento

ensine o mecanismo

Uma simulação cujo cada efeito tem uma causa legível é uma ferramenta de ensino: veja um índice de ferida acordar um planeta, uma cadeia alimentar colapsar, uma faixa climática mudar - o mecanismo é visível porque é real, não scriptado para a aula.

Não para um game jam de fim de semana

recompensa profundidade

A ASE recompensa construir um mundo, não entregar uma cena até domingo à noite. Se você quer um protótipo do tamanho de um jam em 48 horas, uma engine mais leve se encaixa melhor - a ASE é para a construção longa que um mundo profundo e vivo realmente precisa.

O que você constrói · kits iniciais montam a estrutura de um gênero - depois você constrói

space-sim - **um kit inicial que a engine entrega**

rpg-quest - **monta a estrutura de um gênero, depois você constrói**

survival-3d - **um kit inicial que a engine entrega**

evolution-sim - **monta a estrutura de um gênero, depois você constrói**

multiplayer-arena - **um kit inicial que a engine entrega**