Frontends com Vibecoding · Capítulo 33 de 33 · 10 min
Animar um grafo de conhecimento amplo em movimento
Terceiro capítulo do bônus: o grafo de conhecimento como mapa de entidades ligadas, o layout de força rodando fora da tela, a renderização em WebGL para milhares de nós e o modo massivo na placa de vídeo, com o grafo real deste curso como primeiro conjunto de dados.
Este capítulo faz parte do curso gratuito Frontends com Vibecoding. Para marcar como concluído e salvar o progresso, abra este capítulo na página do curso.
Um grafo de conhecimento amplo se anima com fluidez quando o cálculo das posições roda fora da tela e o desenho fica com a placa de vídeo. Grafo de conhecimento é o mapa de coisas ligadas por relações com nome, como empresa fundada por pessoa. Com a conta no lugar certo, 20 mil entidades se organizam em aglomerados enquanto o quadro segue a 60 por segundo.
A unidade do grafo é a tripla: sujeito, relação e objeto. Brasil GEO, fundada por, Alexandre Caramaschi. Cada sujeito e cada objeto vira um nó, cada relação vira uma aresta com rótulo, e o mesmo nó reaparecendo em muitas triplas é o que transforma uma lista em grafo. O Google deu nome à ideia em 2012, ao lançar o Knowledge Graph com a frase coisas, e não palavras.
Para quem faz GEO, o grafo é o assunto do negócio. Os motores generativos citam entidades que reconhecem, e reconhecem pelo que está ligado a elas em dados estruturados, no schema.org e nas páginas que se referem umas às outras. Este curso tem o próprio grafo: 15 trilhas, 33 capítulos, 146 recursos, 46 categorias, 14 laboratórios e 22 bibliotecas. São 276 nós e 363 arestas gerados a partir do código.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
A figura abaixo mostra a tripla virando desenho. O nó é a coisa, a aresta é a relação com nome, e o React Flow aparece duas vezes porque é ensinado por um capítulo e pertence a uma categoria. Esse reaparecimento é a costura do grafo, e é ele que o layout precisa respeitar quando arruma os pontos na tela.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
O desenho nasce de três forças. Todos os pontos se repelem, os pontos ligados se puxam como por uma mola, e uma gravidade fraca puxa tudo para o centro. Repetida milhares de vezes, essa conta separa o grafo em aglomerados, que são as comunidades, e deixa no meio os poucos pontos que ligam um aglomerado ao outro. O algoritmo padrão é o ForceAtlas2, publicado em 2014 pela equipe do Gephi.
O custo dessa conta é o que trava a tela. Cada rodada compara pontos entre si, e com 20 mil pontos a comparação completa passa de 200 milhões de pares. Duas decisões resolvem: a aproximação de Barnes e Hut, que agrupa pontos distantes num só, e o Web Worker, o fio de execução separado que faz a conta enquanto a tela só desenha. O laboratório abaixo usa as duas, pela biblioteca graphology.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Desenhar é a outra metade. O sigma.js, na versão 3 de março de 2024, desenha o grafo em WebGL, a interface que entrega o desenho à placa de vídeo, e mantém dezenas de milhares de nós e arestas interativos. Acima de 5 mil nós ele esconde as arestas enquanto a câmera se move e mostra rótulo só nos nós maiores, e é isso que segura os 60 quadros por segundo.
Quando o grafo passa de 100 mil pontos, a própria conta das forças vai para a placa de vídeo. O cosmos.gl, motor entregue à OpenJS Foundation em 2025 e reescrito na versão 3 sobre o luma.gl, calcula as forças e desenha em WebGL 2 e chega a um milhão de pontos no navegador. O laboratório traz os dois motores, para a pessoa ver onde um para e o outro continua.
Que motor para que tamanho de grafo
| Motor | Onde roda o layout | Nós confortáveis | Rótulos e interação | Quando entra |
|---|---|---|---|---|
| React Flow 12 | Sem layout automático; posições vêm prontas | Até algumas centenas | Nó é HTML: qualquer texto, botão e estado | Fluxo com estado por nó, como o orquestrador da aula 1 |
| d3-force com Canvas 2D | Na thread principal, ou num worker que você escreve | Até cerca de 3 mil | Rótulo desenhado à mão no canvas | Grafo pequeno com desenho totalmente próprio |
| sigma.js 3 com graphology | ForceAtlas2 em Web Worker, com Barnes e Hut | Até dezenas de milhares | Rótulos nos maiores, destaque de vizinhos, busca e câmera | Grafo de conhecimento com leitura: o padrão desta aula |
| cosmos.gl 3 | Força e desenho na placa de vídeo (WebGL 2) | Centenas de milhares a um milhão | Ponto e ligação; rótulo por camada separada | Mostrar a escala: o modo massivo do laboratório |
| Cytoscape.js e vis-network | Vários layouts na thread principal | Até alguns milhares | Completos, com estilos por seletor | Ferramenta interna de análise, sem a exigência de fluidez |
Suba de motor só quando o de baixo travar a sua tela com o seu grafo; o medidor do laboratório é a prova.
O laboratório abaixo começa pelo grafo real do curso, com rótulos. Rode o layout e veja os aglomerados se formarem: as trilhas puxam os capítulos, os capítulos puxam os recursos e as categorias ficam no meio, ligando tudo.
O interruptor troca para o sintético de até 20 mil nós, e o segundo painel carrega o modo massivo na placa de vídeo, com até 200 mil pontos. O medidor mostra quadros por segundo e iterações do layout enquanto tudo acontece.
Ver o grafo real do curso e um grafo de milhares de nós se organizarem em aglomerados
Rode o layout no grafo real, passe o mouse pelos nós e busque uma entidade; troque para 20 mil nós e leia o medidor; depois carregue o modo massivo na placa de vídeo.
Demonstração em dois painéis. No primeiro, o sigma.js desenha em WebGL o grafo real deste curso, com 276 nós e 363 arestas rotulados, ou um grafo sintético de 1.000 a 20.000 nós; o ForceAtlas2 roda num Web Worker e a pessoa vê os aglomerados se formarem, com destaque de vizinhos ao passar o mouse, busca por entidade, ficha do nó com link e medidor de quadros por segundo e de iterações do layout. No segundo, o cosmos.gl calcula as forças e desenha na placa de vídeo um grafo de 50 mil a 200 mil pontos, com tempo até estabilizar. Sem WebGL 2, fica o primeiro painel. Com movimento reduzido ativo, o layout só roda por botão e a câmera não anima.
A demonstração interativa carrega quando este trecho entra na tela.
Quatro cuidados fazem a cena ensinar em vez de hipnotizar. O layout converge e para: grafo que se mexe para sempre é enfeite, e a pessoa não consegue ler.
A cor por tipo de nó tem legenda em texto ao lado do palco. O rótulo aparece só onde cabe, e a busca leva ao resto. E o número de nós aparece com a fonte: o grafo real diz de onde veio, e o sintético se declara cenário ilustrativo.
O trecho abaixo é o centro do laboratório. Ele mostra o grafo em graphology, o layout no worker com as configurações inferidas do tamanho, o sigma com o destaque de vizinhos e o cosmos recebendo posições e ligações em arrays tipados. O componente inteiro está no download.
import Graph from "graphology";
import forceAtlas2 from "graphology-layout-forceatlas2";
import FA2Layout from "graphology-layout-forceatlas2/worker";
import Sigma from "sigma";
// 1. O grafo: nós com rótulo, tipo, cor por token e tamanho por grau; posições iniciais em círculo.
const grafo = new Graph();
for (const n of dados.nodes) grafo.addNode(n.id, { label: n.label, tipo: n.type, size: 3, color: corDoTipo(n.type), x: 0, y: 0 });
for (const e of dados.edges) grafo.addEdge(e.source, e.target, { tipo: e.type });
grafo.forEachNode((id, a) => grafo.mergeNodeAttributes(id, { size: 3 + Math.sqrt(grafo.degree(id)), ...posicaoEmCirculo(a) }));
// 2. O layout fora da tela: ForceAtlas2 num Web Worker, com Barnes e Hut acima de 2.000 nós.
const layout = new FA2Layout(grafo, { settings: { ...forceAtlas2.inferSettings(grafo), barnesHutOptimize: grafo.order > 2000 } });
layout.start(); // a tela só desenha; layout.stop() quando os aglomerados assentarem
// 3. O desenho em WebGL, com destaque de vizinhos e rótulos só nos maiores.
const sigma = new Sigma(grafo, palco, { renderLabels: true, labelRenderedSizeThreshold: 8, hideEdgesOnMove: grafo.order > 5000 });
let focado: string | null = null;
sigma.on("enterNode", ({ node }) => { focado = node; sigma.refresh(); });
sigma.setSetting("nodeReducer", (id, a) => (focado && id !== focado && !grafo.areNeighbors(id, focado) ? { ...a, color: cinza, label: "" } : a));
sigma.setSetting("edgeReducer", (id, a) => (focado && !grafo.hasExtremity(id, focado) ? { ...a, hidden: true } : a));
// 4. O modo massivo: cosmos.gl calcula e desenha na GPU a partir de arrays tipados.
const { Graph: Cosmos } = await import("@cosmos.gl/graph");
const cosmos = new Cosmos(canvasGpu, { simulationGravity: 0.25, simulationRepulsion: 1, simulationLinkSpring: 1, onSimulationEnd: marcarTempo });
cosmos.setPointPositions(posicoes); cosmos.setLinks(ligacoes); cosmos.render(); cosmos.start();Antes de aprovar uma cena de grafo, peça o print do medidor com o seu grafo, e não com o de exemplo. Se o quadro cair abaixo de 30 por segundo enquanto o layout roda, a conta está na thread errada ou o motor é pequeno demais para o tamanho.
Se o grafo nunca para, falta o critério de convergência. E se a pessoa não encontra a própria empresa em cinco segundos, falta a busca, que vale mais que qualquer efeito.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. Nos vídeos e áudios, use Anotar este momento. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Conexões deste capítulo
Explore os conceitos e compare abordagens em outros cursos. As conexões indicam assuntos relacionados; a sequência de estudo continua no índice do curso.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Bastidores: Como Este Portal Foi ConstruídoO motor de cursos: conteúdo como códigoExaminar conexões de O motor de cursos: conteúdo como código
- SEO ProgramáticoTestar o template no pior caso e achar o tetoExaminar conexões de Testar o template no pior caso e achar o teto
- Agentes de IA Autônomos: Do Conceito à ProduçãoLangGraph fundamentosExaminar conexões de LangGraph fundamentos
- Dados com PythonMatplotlib e SeabornExaminar conexões de Matplotlib e Seaborn
Voltar ao capítulo anterior: Especificar, medir e produzir as cenas da máquina
Laboratórios ao vivo deste curso
Cada laboratório monta a biblioteca real dentro da aula, com controles para você mexer e o código do exemplo para copiar. O texto de reserva descreve a demonstração para quem lê sem JavaScript. O link abre o capítulo já no ponto do laboratório.
Base UI
Prenda o foco num diálogo sem escrever o comportamento
Abra a janela Agendar visita, percorra os campos com Tab, feche com Esc e acompanhe no painel onde o foco está e para onde ele volta.
Pacote
Abrir no capítuloConstruir componentes, usar o registro e publicar o catálogo@base-ui/reactLucide e Iconify
Mantenha uma família de ícones coerente e nomeie cada botão
Mude tamanho, traço e cor da barra, veja o símbolo do Iconify acompanhar o Lucide e rode a auditoria de nomes acessíveis.
Pacote
Abrir no capítuloProjetar uma linguagem de ícones e ilustraçãolucide-react, @iconify/reactMotion
Testar os três sinais que autorizam o terceiro degrau
Reproduza a entrada em sequência, aperte o botão com mola e arraste o cartão; ajuste rigidez e amortecimento e veja o que muda.
Pacote
Abrir no capítuloProjetar movimento, assinatura e narrativas por rolagemmotionVidstack
Ver o que separa um player de um vídeo cru
Dê o play, troque a velocidade e ligue a legenda; o painel ao lado mostra o estado que o player publica e que a etiqueta crua esconde.
Pacote
Abrir no capítuloProjetar movimento, assinatura e narrativas por rolagem@vidstack/reactcmdk
Achar um destino entre quarenta digitando três letras
Abra a paleta, digite fat e escolha um item só pelo teclado; o painel embaixo conta o que o filtro deixou passar e quanto tempo levou.
Pacote
Abrir no capítuloConstruir formulários e estados de interaçãocmdknumber-flow
Animar indicadores que mudam ao vivo com formato pt-BR
Veja três indicadores fictícios rolarem a cada troca e compare com o número em texto puro. Pause, reinicie e observe o separador de milhar.
Pacote
Abrir no capítuloProjetar gráficos e painéis pela decisão@number-flow/reactApache ECharts
Medir o custo de desenhar 200 mil pontos com o ECharts
Troque o tipo de gráfico e o volume de pontos, leia o tempo de desenho e alterne o eixo em zero. Mude o tema do site e veja as cores refazerem.
Pacote
Abrir no capítuloProjetar gráficos e painéis pela decisãoechartssharp e svgo
Escolher a variante certa da imagem e conferir o teto de 150 KB
Arraste a largura da tela simulada, troque a densidade entre 1x e 2x e veja qual arquivo o navegador escolhe, quanto ele pesa e se cabe no orçamento.
Pacote
Abrir no capítuloValidar desempenho, autenticação e segurançasharp, svgoReact Flow (xyflow)
Disparar um pedido e ver o orquestrador distribuir, conferir e responder
Alterne paralelo e sequencial, ligue e desligue a verificação e use a medição real; observe o tempo de parede em cada combinação.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robô@xyflow/reactGSAP, Web Workers e number-flow
Dividir mil tarefas entre trabalhadores reais e correr três ritmos de geração
Execute com um trabalhador, depois com quatro e oito, e compare o tempo; em seguida percorra a corrida e separe a espera inicial do ritmo.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robôgsap, @number-flow/reactThree.js com React Three Fiber, drei, Rapier e XR
Carregar o braço robótico, ver a física trabalhar e entrar na cena com o visor
Carregue a cena pelo botão, inicie o ciclo, mostre os ângulos das juntas, troque a câmera e a velocidade; com visor, entre em realidade virtual.
Pacote
Abrir no capítuloConstruir as cenas do orquestrador, do paralelismo e do robôthree, @react-three/fiber, @react-three/drei, @react-three/rapier, @react-three/xrMotion
Ver quatro agentes em raias trocando mensagens e a revisão devolvendo um trecho
Reproduza os 60 s de modelo, percorra o tempo pelo controle e esconda as mensagens para comparar a leitura; repare no tempo de parede contra a soma.
Pacote
Abrir no capítuloEspecificar, medir e produzir as cenas da máquinamotionMediaRecorder, Canvas 2D e Long Animation Frames (plataforma)
Medir o quadro da cena e gravar seis segundos dela em vídeo
Suba as partículas, force um bloqueio de 300 ms e leia o medidor; depois grave seis segundos, veja o codec escolhido e baixe o arquivo.
Pacote
Abrir no capítuloEspecificar, medir e produzir as cenas da máquinasem pacotesigma.js, graphology com ForceAtlas2 e cosmos.gl
Ver o grafo real do curso e um grafo de milhares de nós se organizarem em aglomerados
Rode o layout no grafo real, passe o mouse pelos nós e busque uma entidade; troque para 20 mil nós e leia o medidor; depois carregue o modo massivo na placa de vídeo.
Pacote
Abrir no capítuloAnimar um grafo de conhecimento amplo em movimentosigma, graphology, graphology-layout-forceatlas2, graphology-generators, @cosmos.gl/graph
Capítulos vizinhos em Frontends com Vibecoding
- 29Construir um aplicativo instalável e resiliente
- 30Produzir apresentações e PDF com critérios de entrega
- 31Construir as cenas do orquestrador, do paralelismo e do robô
- 32Especificar, medir e produzir as cenas da máquina
- 33Animar um grafo de conhecimento amplo em movimento