# Word, Excel, PowerPoint, Markdown, PowerPoint, Visio, OneNote, Email as C#/MIT

> Source: <https://officeimo.com/>
> Published: 2026-07-27 06:50:03+00:00

## Project Overview

### Executive summary

Structured document output with headings, paragraphs, tables, images, and metadata.

Use typed .NET packages for the full DOC, XLS, XLSB, PPT, and modern Office surface. Use PSWriteOffice for its documented PowerShell authoring, inspection, and conversion workflows — all without Microsoft Office.

Structured document output with headings, paragraphs, tables, images, and metadata.

Repeatable presentations from application data.

``` js
using var doc =
    WordDocument.Load("legacy.doc");
doc.Save("modern.docx");
```

Build Word, Excel, PowerPoint, PDF, Visio, Markdown, CSV, and other document formats from typed .NET APIs.

Move content between Office, PDF, HTML, Markdown, OpenDocument, RTF, and Google Workspace with focused converter packages.

Normalize text, tables, metadata, images, and chunks for search, review, ingestion, and AI-assisted workflows.

Use PSWriteOffice for scheduled reports, administration scripts, build pipelines, and repeatable document jobs.

Product family

Install only the document engines, converters, readers, or automation surfaces your application needs.

Build the document your application needs with a native, typed model.

Create, read, edit, and convert DOC, DOCX, DOCM, and Word templates with explicit compatibility diagnostics.

Create, read, edit, and convert XLS, XLSX, XLSB, and macro-enabled workbooks without Excel.

Create, read, edit, and convert PPT, PPTX, PPS, and POT presentations with preservation-aware legacy handling.

Create, inspect, edit, merge, sign, validate, and render PDF files.

Work with native OneNote sections, notebooks, tables of contents, and packages offline.

Move structured content across document, web, and interchange formats with explicit diagnostics.

Read and write email, Outlook items, mailbox stores, calendars, and contacts.

Create and edit ODT, ODS, and ODP without LibreOffice or Office.

Parse HTML and MHTML, apply resource policy, and render to document or image formats.

Read, create, preserve, and convert RTF with bounded parsing and fidelity reports.

Extract EPUB metadata, navigation, chapters, and bounded resources.

Build, parse, transform, and render Markdown with a typed AST.

Create VSDX diagrams with pages, shapes, connectors, and metadata.

Read heterogeneous files, connect Google Workspace, or run the same capabilities from PowerShell.

Extract normalized text, tables, metadata, assets, and chunks across document families.

Translate Office content to and from Docs, Sheets, and Slides with explicit fidelity decisions.

Create, convert, and inspect documents from PowerShell scripts and automation jobs.

Call focused .NET packages from applications and services, or use PSWriteOffice for script-first document automation.

``` js
using var doc = WordDocument.Create("report.docx");

var paragraph = doc.AddParagraph("Quarterly Sales Report");
paragraph.Style = WordParagraphStyle.Heading1;

doc.AddParagraph("Generated automatically with OfficeIMO.Word.");

var table = doc.AddTable(4, 3);
table.Rows[0].Cells[0].Paragraphs[0].Text = "Region";
table.Rows[0].Cells[1].Paragraphs[0].Text = "Revenue";
table.Rows[0].Cells[2].Paragraphs[0].Text = "Growth";
table.Rows[0].IsHeader = true;

table.Rows[1].Cells[0].Paragraphs[0].Text = "North America";
table.Rows[1].Cells[1].Paragraphs[0].Text = "$1,250,000";
table.Rows[1].Cells[2].Paragraphs[0].Text = "+12%";

doc.Save();
js
using var doc = ExcelDocument.Load("sales-data.xlsx");
var sheet = doc.WorkSheets[0];

// Read typed data from rows
var rows = sheet.RowsAs(r => new SalesRecord {
    Region = r.String("Region"),
    Revenue = r.Decimal("Revenue"),
    Growth = r.Double("Growth")
});

// Add a summary chart
var chart = sheet.AddChart(ExcelChartType.ColumnClustered);
chart.Title = "Revenue by Region";
chart.AddSeries("Revenue", rows.Select(r => r.Revenue));

doc.Save("sales-report.xlsx");
PowerPointDesignBrief brief = PowerPointDesignBrief
    .FromBrand("#008C95", "client-demo", "technical rollout proposal")
    .WithIdentity("Client Theme", footerLeft: "CLIENT", footerRight: "Service deck")
    .WithVariety(PowerPointDesignVariety.Exploratory);

var plan = new PowerPointDeckPlan()
    .AddSection("Service proposal", "Generated from a semantic plan.")
    .AddProcess("Implementation path", "The selected design handles layout.", new[] {
        new PowerPointProcessStep("Discover", "Collect constraints."),
        new PowerPointProcessStep("Design", "Choose the target model."),
        new PowerPointProcessStep("Roll out", "Deliver in waves.")
    });

var best = brief.DescribeDeckPlanAlternatives(plan, 3)
    .OrderByDescending(alternative => alternative.ContentFitScore)
    .First();

using var ppt = PowerPointPresentation.Create("proposal.pptx");
ppt.SlideSize.SetPreset(PowerPointSlideSizePreset.Screen16x9);
ppt.UseDesigner(brief, best.Index).AddSlides(plan);
ppt.Save();
js
var doc = MarkdownDoc.Create()
    .H1("Release Notes")
    .P("Version 2.0 brings major improvements.")
    .H2("New Features")
    .BulletList(
        "Parallel Excel operations",
        "PowerPoint chart support",
        "AOT-ready CSV module"
    )
    .H2("Performance")
    .Table(t => t.FromSequence(benchmarks,
        ("Scenario", b => b.Name),
        ("Before", b => b.Before),
        ("After", b => b.After)
    ));

var html = doc.ToHtmlFragment();
File.WriteAllText("release-notes.md", doc.ToString());
New-OfficeWord -FilePath 'Report.docx' {
    WordSection {
        WordParagraph -Text 'Monthly Report' -Style Heading1
        WordParagraph -Text 'Generated with PSWriteOffice'

        WordTable -DataTable $SalesData -Style LightGrid
    }
}

New-OfficeExcel -FilePath 'Data.xlsx' {
    ExcelSheet -Name 'Sales' {
        ExcelTable -DataTable $Records -AutoFilter -AutoFit
    }
    ExcelSheet -Name 'Charts' {
        ExcelChart -Type ColumnClustered -Title 'Revenue'
    }
}
```

Run the example, inspect the source, and download the real output. Each card states what the evidence proves and where fidelity is intentionally bounded.

Generate editable slides from a brand brief, rank deterministic design alternatives, and validate the resulting Open XML package.

Build a dependency-free PDF report with branded sections, summary metrics, tables, drawing primitives, and page-aware layout.

Parse a styled invoice once, apply an explicit resource and layout policy, and produce PDF, PNG, or SVG output through the shared renderer.

Create an editable delivery report with headings, lists, and operational tables, then convert the same Word model to a review-ready PDF.

No. OfficeIMO uses managed, first-party document engines and does not require Microsoft Office, COM automation, or Office interop assemblies at runtime. That includes supported Word 97–2003 DOC, Excel XLS/XLSB, PowerPoint PPT/POT/PPS, modern Office, PDF, OpenDocument, email, and publishing workflows. Optional desktop Office checks are validation oracles, not runtime dependencies.

Yes. OfficeIMO classifies and reads modern and legacy Word, Excel, and PowerPoint families, writes documented native subsets, and supports bidirectional conversions. Coverage is reported by operation and fidelity rather than by extension alone. Check the [compatibility dashboard](/compatibility/) for current formats, tracked behaviors, fallbacks, and deliberate blocks.

OfficeIMO targets **.NET 8.0**, **.NET 10.0**, **.NET Standard 2.0**, and **.NET Framework 4.7.2**. This means it works with .NET Core, .NET 5+, and legacy .NET Framework projects.

Yes. The OfficeIMO packages themselves are published under the **MIT License**. However, some optional package families build on third-party dependencies with their own upstream terms, so commercial teams should also review our [Third-Party Dependencies](/third-party/) page during OSS approval.

OfficeIMO is an MIT-licensed, source-available document platform for .NET and PowerShell with modern and legacy Office support, focused packages, explicit conversion-fidelity policies, and no runtime royalty. Commercial suites can provide broader portfolio coverage, more mature rendering for some workloads, formal support, and procurement SLAs. Compare the exact formats, operations, fidelity, deployment model, and support obligations your application needs on our [evaluation page](/comparison/).

Free, open source, and MIT licensed. Install in seconds.

`dotnet add package OfficeIMO.Word`

`Install-Module PSWriteOffice`