Skip to content
Office Oxide

Criar documentos Office a partir do Markdown

create_from_markdown cria um DOCX, XLSX ou PPTX novo a partir de uma única string Markdown. Uma fonte Markdown, três formatos de saída. O Markdown é o destino natural para conteúdo gerado por LLMs: peça ao modelo que produza Markdown — muito mais confiável do que pedir que ele gere Office XML diretamente — e depois materialize o formato Office adequado sob demanda.

Internamente, o Markdown é analisado e convertido para o DocumentIR estruturado do Office Oxide e renderizado no formato de destino, garantindo o mesmo mapeamento determinístico e independente de formato. O IR em si é principalmente uma interface de extração e inspeção (veja to_ir()); para criação, o ponto de entrada público em todos os bindings é o Markdown.

Qual é a assinatura de create_from_markdown?

A função recebe uma string Markdown, um formato de destino ("docx", "xlsx" ou "pptx", sem distinção de maiúsculas/minúsculas) e um caminho de saída. Não retorna nada em caso de sucesso e lança/retorna um erro em caso de falha.

Binding Assinatura
Python def create_from_markdown(markdown: str, format: str, path, /) -> None
Rust pub fn create_from_markdown(markdown: &str, format: DocumentFormat, path: impl AsRef<Path>) -> Result<()>
Go func CreateFromMarkdown(markdown, format, path string) error
JavaScript createFromMarkdown(markdown, format, path)
C# static void Document.CreateFromMarkdown(string markdown, string format, string path)

Como criar um DOCX, XLSX ou PPTX a partir do Markdown?

Escreva seu conteúdo uma vez em Markdown e altere o argumento format para escolher o formato de destino.

Rust

use office_oxide::create::create_from_markdown;
use office_oxide::format::DocumentFormat;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let markdown = "\
# Quarterly Report

Generated automatically from Markdown using Office Oxide.

## Highlights

- Revenue grew by **32%** year-over-year
- Customer satisfaction: 4.8 / 5.0

## Financial Summary

| Category   | Q3 2025 | Q4 2025 |
|------------|---------|---------|
| Revenue    | $1.2M   | $1.6M   |
| Net Profit | $0.4M   | $0.7M   |
";

    create_from_markdown(markdown, DocumentFormat::Docx, "report.docx")?;
    create_from_markdown(markdown, DocumentFormat::Xlsx, "report.xlsx")?;
    create_from_markdown(markdown, DocumentFormat::Pptx, "report.pptx")?;
    Ok(())
}

Python

from office_oxide import create_from_markdown

markdown = """\
# Quarterly Report

Generated automatically from Markdown using Office Oxide.

## Highlights

- Revenue grew by **32%** year-over-year
- Customer satisfaction: 4.8 / 5.0
- New products launched: Widget Pro, Widget Lite

## Financial Summary

| Category   | Q3 2025 | Q4 2025 |
|------------|---------|---------|
| Revenue    | $1.2M   | $1.6M   |
| Expenses   | $0.8M   | $0.9M   |
| Net Profit | $0.4M   | $0.7M   |
"""

# One Markdown source, three target formats:
create_from_markdown(markdown, "docx", "report.docx")
create_from_markdown(markdown, "xlsx", "report.xlsx")
create_from_markdown(markdown, "pptx", "report.pptx")

JavaScript

import { createFromMarkdown } from 'office-oxide';

const markdown = `# Quarterly Report

Generated automatically from Markdown using Office Oxide.

## Highlights

- Revenue grew by **32%** year-over-year
- Customer satisfaction: 4.8 / 5.0

## Financial Summary

| Category   | Q3 2025 | Q4 2025 |
|------------|---------|---------|
| Revenue    | $1.2M   | $1.6M   |
| Net Profit | $0.4M   | $0.7M   |
`;

for (const fmt of ['docx', 'xlsx', 'pptx']) {
  createFromMarkdown(markdown, fmt, `report.${fmt}`);
}

Go

package main

import (
    "log"

    oo "github.com/yfedoseev/office_oxide/go"
)

func main() {
    markdown := `# Quarterly Report

Generated automatically from Markdown using Office Oxide.

## Highlights

- Revenue grew by **32%** year-over-year
- Customer satisfaction: 4.8 / 5.0

## Financial Summary

| Category   | Q3 2025 | Q4 2025 |
|------------|---------|---------|
| Revenue    | $1.2M   | $1.6M   |
| Net Profit | $0.4M   | $0.7M   |
`

    for _, fmt := range []string{"docx", "xlsx", "pptx"} {
        if err := oo.CreateFromMarkdown(markdown, fmt, "report."+fmt); err != nil {
            log.Fatalf("CreateFromMarkdown(%s): %v", fmt, err)
        }
    }
}

C#

using OfficeOxide;

const string markdown = """
    # Quarterly Report

    Generated automatically from Markdown using Office Oxide.

    ## Highlights

    - Revenue grew by **32%** year-over-year
    - Customer satisfaction: 4.8 / 5.0

    ## Financial Summary

    | Category   | Q3 2025 | Q4 2025 |
    |------------|---------|---------|
    | Revenue    | $1.2M   | $1.6M   |
    | Net Profit | $0.4M   | $0.7M   |
    """;

foreach (var fmt in new[] { "docx", "xlsx", "pptx" })
{
    Document.CreateFromMarkdown(markdown, fmt, $"report.{fmt}");
}

C

#include <stdio.h>
#include "office_oxide.h"

int main(void) {
    const char *markdown =
        "# Quarterly Report\n\n"
        "Generated automatically from Markdown using Office Oxide.\n\n"
        "## Highlights\n\n"
        "- Revenue grew by **32%** year-over-year\n"
        "- Customer satisfaction: 4.8 / 5.0\n\n"
        "## Financial Summary\n\n"
        "| Category   | Q3 2025 | Q4 2025 |\n"
        "|------------|---------|---------|\n"
        "| Revenue    | $1.2M   | $1.6M   |\n"
        "| Net Profit | $0.4M   | $0.7M   |\n";

    /* format: "docx" | "xlsx" | "pptx" (case-insensitive) */
    const char *formats[] = { "docx", "xlsx", "pptx" };
    for (int i = 0; i < 3; i++) {
        int err = 0;
        char path[32];
        snprintf(path, sizeof(path), "report.%s", formats[i]);
        if (office_create_from_markdown(markdown, formats[i], path, &err) != 0) {
            fprintf(stderr, "create_from_markdown(%s) failed: code=%d\n", formats[i], err);
            return 1;
        }
    }
    return 0;
}

Como cada formato de destino renderiza o Markdown?

O Markdown é analisado e convertido para o IR estruturado do Office Oxide, e então cada formato renderiza essa estrutura de forma determinística:

Construção Markdown DOCX XLSX PPTX
Título # Parágrafo com estilo Heading{level} Célula em negrito no topo de uma seção Espaço reservado para título do slide
Texto de parágrafo Parágrafo de corpo Células em linhas sucessivas Espaço reservado para texto do corpo
Lista - / 1. Lista com marcadores ou numerada Células na coluna A Marcadores do corpo
Tabela Tabela do Word Células a partir da próxima linha livre Tabela do PowerPoint
**negrito** / *itálico* Formatação de texto inline Texto simples na célula Formatação de texto inline

O mapeamento é conservador: cada construção Markdown produz saída determinística, mas cada formato Office possui recursos que o Markdown não modela (formatos de número de célula no XLSX, animações no PPTX, threads de comentários no DOCX). Para saída mais rica, crie o arquivo e edite-o com o editor específico do formato, ou use os escritores específicos de formato.

Como ler, modificar e escrever de volta entre formatos?

Combine extração e criação para fazer edições de conteúdo que funcionam entre formatos. Leia o arquivo fonte como Markdown, modifique o Markdown e escreva um novo arquivo:

Python

from office_oxide import Document, create_from_markdown

with Document.open("legacy.doc") as doc:
    markdown = doc.to_markdown()

# Append a new section
markdown += "\n## Appendix\n\nEffective 2026-06-22.\n"

create_from_markdown(markdown, "docx", "modernized.docx")

C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "office_oxide.h"

int main(void) {
    int err = 0;

    /* Read the source as Markdown */
    OfficeDocumentHandle *doc = office_document_open("legacy.doc", &err);
    if (!doc) { fprintf(stderr, "open failed: code=%d\n", err); return 1; }
    char *md = office_document_to_markdown(doc, &err);
    office_document_free(doc);
    if (!md) { fprintf(stderr, "to_markdown failed: code=%d\n", err); return 1; }

    /* Append a new section */
    const char *appendix = "\n## Appendix\n\nEffective 2026-06-22.\n";
    char *modified = malloc(strlen(md) + strlen(appendix) + 1);
    strcpy(modified, md);
    strcat(modified, appendix);
    office_oxide_free_string(md);

    /* Write a fresh file */
    office_create_from_markdown(modified, "docx", "modernized.docx", &err);
    free(modified);
    return err;
}

Este também é um caminho limpo para modernização de legado → OOXML (DOC → DOCX, XLS → XLSX, PPT → PPTX) quando você só precisa da estrutura textual. Para uma conversão que preserve a estrutura e mantenha o layout original, use save_as(), que faz a viagem de ida e volta pelo IR. Veja Conversão: legado → OOXML.

Por que gerar arquivos Office a partir do Markdown?

  • Templates independentes de formato. Gere o mesmo conteúdo como DOCX (para usuários do Word), XLSX (para analistas) ou PPTX (para apresentações) sem reescrever nada — apenas mude o argumento format.
  • Nativo para LLMs. Faça o modelo produzir Markdown e materialize o arquivo. Markdown é o que os modelos geram com mais confiabilidade.
  • Com suporte a diff. Markdown é texto simples; commite-o. O arquivo Office vira um artefato de build.
  • Rápido. O núcleo Rust do Office Oxide escreve arquivos em milissegundos, com taxa de aprovação de 100% no corpus de benchmarks.

Avançado: construir diretamente a partir de um DocumentIR (Rust)

O crate Rust também expõe create_from_ir para quem quiser construir ou transformar o IR estruturado manualmente em vez de passar pelo Markdown:

use office_oxide::create::create_from_ir;
use office_oxide::format::DocumentFormat;
use office_oxide::ir::DocumentIR;

// Build or transform a DocumentIR however you like, then render it:
let ir: DocumentIR = DocumentIR::from_markdown("# Title\n\nBody.\n", DocumentFormat::Docx);
create_from_ir(&ir, DocumentFormat::Docx, "report.docx")?;

pub fn create_from_ir(ir: &DocumentIR, format: DocumentFormat, path: impl AsRef<Path>) -> Result<()>

Nos bindings Python, Go, JavaScript e C#, o IR é somente leitura — obtenha-o com to_ir() para inspeção e pipelines, e crie arquivos com create_from_markdown.

Limitações

  • Formatação de células (formatos de número, moeda, estilos personalizados) não é expressa em Markdown. Adicione via editor específico do formato após a criação.
  • Imagens, gráficos, smart art e objetos incorporados não são transportados pelo caminho Markdown — use os escritores específicos de formato (XlsxWriter, PptxWriter ou o builder DOCX) para isso.
  • Mesclagem de células no XLSX, animações no PPTX e threads de comentários no DOCX não têm equivalente em Markdown.

Para tudo além do alcance expressivo do Markdown, use os escritores específicos de formato. Eles oferecem acesso completo aos recursos OOXML ao custo de serem específicos de formato.

Perguntas frequentes

Quais formatos o create_from_markdown pode produzir? DOCX, XLSX e PPTX. O argumento format é "docx", "xlsx" ou "pptx" (sem distinção de maiúsculas/minúsculas). Formatos binários legados (DOC, XLS, PPT) são somente leitura e não podem ser criados.

Existe uma função create_from_ir em Python ou outros bindings? Não. create_from_ir é exposta apenas no crate Rust. Em Python, Go, JavaScript e C#, crie arquivos com create_from_markdown; o IR (to_ir/to_ir_json) é um conceito somente leitura do lado da extração.

Como fazer a viagem de ida e volta de um documento existente mantendo seu layout? Use save_as() para conversão com preservação de estrutura. Use to_markdown() + create_from_markdown() quando só precisar reconstruir a estrutura textual de forma limpa.

Qual é a velocidade de criação de documentos? O núcleo Rust do Office Oxide escreve arquivos Office em milissegundos, com taxa de aprovação de 100% no corpus de benchmarks — rápido o suficiente para gerar documentos sob demanda dentro de um handler de requisição.

Veja também