Em breve · Open Source · Modified MIT
A planilha para humanos e agentes.
Um motor de planilhas open-source reconstruído em Rust. Arrays dinâmicos, tabelas dinâmicas, XLOOKUP — com SDKs para Python e Node.js feitos para IA.
Os pacotes do SDK serão publicados no lançamento. Siga para novidades
Planilha real rodando no seu navegador via WebAssembly — não é uma captura de tela.
Casos de Uso
Feito para desenvolvedores e agentes
Incorpore no seu app
Adicione uma planilha completa em qualquer aplicação web com um único componente React. Arrays dinâmicos, tabelas dinâmicas e 582 funções prontas para uso.
Rode no servidor
Processe arquivos XLSX, avalie fórmulas e gere relatórios no servidor com o SDK de Node.js ou Python. Sem necessidade de navegador.
Alimente agentes de IA
Dê a LLMs acesso estruturado a operações de planilha. A API tipada do SDK foi projetada para tool-use — sem screen scraping ou engenharia de prompt.
Por que Mog
Um motor de planilhas completo, não apenas um componente de UI.
Feito para humanos e agentes
Uma API estruturada que LLMs podem chamar diretamente. SDKs para Python e Node.js projetados para workflows de agentes de IA — sem screen scraping ou gambiarras com macros.
- SDK Python via PyO3 para workflows de agentes de IA
- SDK Node.js via N-API com performance nativa
- Servidor headless para processamento em lote
- API pronta para tool-use (entrada/saída estruturada)
Compatibilidade total com Excel, reconstruída em Rust
582 funções, arrays dinâmicos, tabelas dinâmicas, XLOOKUP, formatação condicional e referências estruturadas. Não é um subconjunto — é completo.
- 582 funções compatíveis com Excel
- Arrays dinâmicos, XLOOKUP, LAMBDA
- Tabelas dinâmicas, formatação condicional, validação de dados
- Leitura e escrita nativa de XLSX (spec OOXML completa)
Tempo real, offline-first, sem conflitos
Colaboração baseada em CRDT com Yrs. Funciona offline, sincroniza quando conectado, nunca perde dados. Sem a complexidade de operational transform.
- Colaboração CRDT via Yrs (Rust)
- Modelo de identidade de células para fórmulas sem conflito
- Offline-first com sincronização automática
- Renderização em canvas a 60fps via protocolo binário
Arquitetura
Um engine em Rust, todas as plataformas
Escrito uma vez em Rust, compilado para três alvos. O mesmo código no navegador, no servidor e em notebooks Python.
Navegador
WebAssembly
Roda em um Web Worker. Zero round-trips ao servidor para computação.
Node.js
N-API
Binários nativos para macOS, Linux e Windows. Sem overhead de WASM.
Python
PyO3
Bindings nativos para Python. Use fórmulas de planilha junto com pandas.
Core computacional em Rust
Fórmulas, grafo de dependências, tabelas dinâmicas, formatação condicional e parser XLSX — tudo em Rust. Uma única API anotada gera bindings para todos os alvos.
compute-core
parser, functions, graph, formats,
schema, stats, charts, cf, pivot,
table, fill, solver, collab, wire
Protocolo binário de comunicação
Dados do viewport como buffers binários compactos, não JSON. Zero alocações por célula. 60fps em planilhas grandes.
Viewport buffer
36B header + N × 32B cell records
+ string pool + format palette
Mutation patches
Spliced directly into the viewport
buffer — no deserialization step
SDK
Acesso programático a tudo
Um engine em Rust, todos os SDKs. A mesma API em Python e TypeScript.
Python
import mog
wb = mog.create_workbook()
ws = wb.active_sheet()
# Set values and formulas
ws.set_cell("A1", "Revenue")
ws.set_cell("A2", 150000)
ws.set_cell("A3", "=A2 * 1.15")
# Dynamic arrays just work
ws.set_cell("B1", '=FILTER(A1:A3, A1:A3>100000)')
# Convert to pandas DataFrame
wb.calculate()
df = ws.to_dataframe()
wb.save("forecast.xlsx")Node.js
import { createWorkbook } from "@mog-sdk/node";
const wb = await createWorkbook();
const ws = wb.getActiveSheet();
// Set values and formulas
await ws.setCell("A1", "Revenue");
await ws.setCell("A2", 150000);
await ws.setCell("A3", "=A2 * 1.15");
// Structured table references
await ws.tables.add({ range: "A1:A3", name: "Forecast" });
await ws.setCell("B1", "=Forecast[@Revenue]");
// Batch operations into a single undo step
await wb.batch(async () => {
await ws.setRange("C1:C3", [["Q2"], [170000], ["=C2*1.15"]]);
});Feito com Mog
Pronto para o seu projeto
De agentes de IA a produtos SaaS e pipelines de dados. Esteja entre os primeiros a construir com Mog.
Agentes de IA
API estruturada de planilhas para tool-use de LLMs. Sem screen scraping.
Produtos SaaS
Planilha completa em um único componente React. Arrays dinâmicos e tudo mais.
Pipelines de dados
Processe XLSX no servidor com Python ou Node.js. Sem precisar do Excel.
Perguntas frequentes
O que é o Mog?
Mog é um motor de planilhas open-source reconstruído do zero em Rust. Ele oferece um runtime completo de planilha — avaliação de fórmulas, rastreamento de dependências, parsing de XLSX, renderização em canvas e colaboração em tempo real — que você pode incorporar em apps web, rodar em servidores ou usar via Python e Node.js.
Por que Rust?
Rust nos dá performance nativa, segurança de memória e a capacidade de compilar para WebAssembly (navegador), N-API (Node.js) e PyO3 (Python) a partir de uma única base de código. Um engine, todas as plataformas, zero pausas de garbage collection.
O Mog é gratuito?
Sim. O Mog é open source sob a licença Modified MIT. Use em projetos pessoais, produtos comerciais ou plataformas SaaS.
Como o Mog se compara a outras bibliotecas de planilha?
A maioria das bibliotecas de planilha foca em renderização de UI ou em parsing de arquivos. O Mog entrega a stack completa: um motor de computação em Rust com 582 funções, renderização em canvas, colaboração CRDT e SDKs nativos. Veja a página de comparação para uma matriz detalhada de funcionalidades.
O Mog está pronto para produção?
O Mog está em desenvolvimento ativo. O engine principal (fórmulas, renderização, colaboração, XLSX) está funcional e em fase de testes. Estamos trabalhando rumo ao lançamento open-source — siga-nos para novidades.
Mais dúvidas? Leia mais sobre o Mog
Quer construir com o Mog?
O Mog será open source sob a licença Modified MIT.
Get notified when Mog launches