Office-Dokumente aus Markdown erstellen

create_from_markdown schreibt ein neues DOCX, XLSX oder PPTX aus einem einzigen Markdown-String. Eine Markdown-Quelle, drei Zielformate. Markdown ist die natürliche Ausgabe für LLM-generierten Inhalt: Das Modell gibt Markdown aus — wesentlich zuverlässiger als direkt Office-XML zu generieren — und anschließend wird das gewünschte Office-Format bei Bedarf erzeugt.

Intern wird das Markdown in das strukturierte DocumentIR von Office Oxide geparst und ins Zielformat gerendert, sodass dieselbe deterministische, formatunabhängige Zuordnung entsteht. Das IR selbst ist primär eine Extraktions- und Inspektionsoberfläche (siehe to_ir()); für die Erstellung ist Markdown der öffentliche Einstiegspunkt in allen Bindings.

Wie lautet die Signatur von create_from_markdown?

Die Funktion nimmt einen Markdown-String, ein Zielformat ("docx", "xlsx" oder "pptx", Groß-/Kleinschreibung egal) und einen Ausgabepfad entgegen. Bei Erfolg gibt sie nichts zurück; bei einem Fehler wirft sie eine Ausnahme oder gibt einen Fehler zurück.

Binding	Signatur
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)

Wie erstelle ich ein DOCX, XLSX oder PPTX aus Markdown?

Schreibe den Inhalt einmal als Markdown und wechsle das format-Argument, um das Zielformat zu wählen.

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;
}

Wie wird Markdown in die jeweiligen Zielformate gerendert?

Das Markdown wird in das strukturierte IR von Office Oxide geparst, dann rendert jedes Format diese Struktur deterministisch:

Markdown-Konstrukt	DOCX	XLSX	PPTX
#-Überschrift	Absatz mit Heading{level}-Stil	Fett formatierte Zelle am Anfang eines Abschnitts	Titelplatzhalter der Folie
Absatztext	Textabsatz	Zellen in aufeinanderfolgenden Zeilen	Textplatzhalter im Hauptbereich
- / 1.-Liste	Aufzählung oder nummerierte Liste	Zellen in Spalte A	Aufzählungspunkte im Hauptbereich
Tabelle	Word-Tabelle	Zellen ab der nächsten freien Zeile	PowerPoint-Tabelle
**Fett** / *Kursiv*	Inline-Textformatierung	Einfacher Zellentext	Inline-Textformatierung

Die Zuordnung ist konservativ: Jedes Markdown-Konstrukt erzeugt deterministische Ausgabe, aber jedes Office-Format hat Funktionen, die Markdown nicht abbildet (XLSX-Zellzahlenformate, PPTX-Animationen, DOCX-Kommentarthreads). Für reichhaltigere Ausgaben erzeuge die Datei und bearbeite sie anschließend mit dem formatspezifischen Editor, oder steige auf die formatspezifischen Writer um.

Wie lese, bearbeite und schreibe ich über Formate hinweg zurück?

Kombiniere Extraktion und Erstellung, um Inhaltsbearbeitungen vorzunehmen, die formatübergreifend erhalten bleiben. Lese die Quelle als Markdown, ändere das Markdown und schreibe eine neue Datei:

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;
}

Dies ist auch ein sauberer Pfad für die Modernisierung von Legacy-Formaten zu OOXML (DOC → DOCX, XLS → XLSX, PPT → PPTX), wenn nur die Textstruktur benötigt wird. Für eine strukturerhaltende Konvertierung, die das ursprüngliche Layout beibehält, verwende save_as(), das über das IR hin und zurück geht. Siehe Konvertierung: Legacy → OOXML.

Warum Office-Dateien aus Markdown generieren?

• Formatunabhängige Vorlagen. Generiere denselben Inhalt als DOCX (für Word-Nutzer), XLSX (für Analysten) oder PPTX (für Präsentationen) ohne Umschreiben — einfach das format-Argument wechseln.
• LLM-nativ. Lass das Modell Markdown erzeugen und materialisiere die Datei. Markdown ist das, was Modelle am zuverlässigsten ausgeben.
• Diff-fähig. Markdown ist Klartext; committe ihn. Die Office-Datei wird zum Build-Artefakt.
• Schnell. Der Rust-Kern von Office Oxide schreibt Dateien in Millisekunden, mit einer 100-%-Bestehensquote auf dem Benchmark-Korpus.

Fortgeschritten: Direkt aus einem DocumentIR aufbauen (Rust)

Das Rust-Crate stellt zusätzlich create_from_ir für Aufrufer bereit, die das strukturierte IR manuell aufbauen oder transformieren möchten, anstatt über Markdown zu gehen:

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<()>

In den Python-, Go-, JavaScript- und C#-Bindings ist das IR schreibgeschützt — erzeuge es mit to_ir() zur Inspektion und für Pipelines, und erstelle Dateien mit create_from_markdown.

Einschränkungen

• Zellformatierung (Zahlenformate, Währung, benutzerdefinierte Stile) lässt sich in Markdown nicht ausdrücken. Füge sie nach der Erstellung über den formatspezifischen Editor hinzu.
• Bilder, Diagramme, SmartArt und eingebettete Objekte werden über den Markdown-Pfad nicht übertragen — verwende dafür die formatspezifischen Writer (XlsxWriter, PptxWriter oder den DOCX-Builder).
• XLSX-Zellverbindungen, PPTX-Animationen und DOCX-Kommentarthreads haben kein Markdown-Äquivalent.

Für alles, was über Markdowns Ausdrucksmöglichkeiten hinausgeht, verwende die formatspezifischen Writer. Sie bieten vollen Zugriff auf OOXML-Funktionen, sind aber an ein bestimmtes Format gebunden.

FAQ

Welche Formate kann create_from_markdown erzeugen? DOCX, XLSX und PPTX. Das format-Argument ist "docx", "xlsx" oder "pptx" (Groß-/Kleinschreibung egal). Legacy-Binärformate (DOC, XLS, PPT) sind schreibgeschützt und können nicht erzeugt werden.

Gibt es eine create_from_ir-Funktion in Python oder anderen Bindings? Nein. create_from_ir ist nur im Rust-Crate verfügbar. In Python, Go, JavaScript und C# werden Dateien mit create_from_markdown erstellt; das IR (to_ir/to_ir_json) ist ein schreibgeschütztes Konzept auf der Extraktionsseite.

Wie mache ich einen Round-Trip durch ein bestehendes Dokument und behalte dabei das Layout? Verwende save_as() für eine strukturerhaltende Konvertierung. Verwende to_markdown() + create_from_markdown(), wenn du nur die Textstruktur sauber neu aufbauen möchtest.

Wie schnell ist die Dokumenterstellung? Der Rust-Kern von Office Oxide schreibt Office-Dateien in Millisekunden, mit einer 100-%-Bestehensquote auf dem Benchmark-Korpus — schnell genug, um Dokumente bei Bedarf direkt in einem Request-Handler zu generieren.

Siehe auch

• Strukturiertes IR — das IR-Schema im Detail (Extraktionsseite)
• Konvertierung: Legacy → OOXML — DOC/XLS/PPT modernisieren
• Bearbeitungsübersicht — bestehende Dateien direkt bearbeiten