# Aspose.3D FOSS URL: https://products.aspose.org/3d/ Load, create, transform, and export 3D scenes — free and open-source, available for .NET, Java, Python, and TypeScript. --- Product: Aspose.3D Page Type: index Canonical URL: https://products.aspose.org/3d/ --- Aspose.3D FOSS is a free, open-source library for loading, manipulating, and saving 3D scenes in OBJ, STL, glTF, COLLADA, 3MF, and FBX formats. MIT licensed. Available for .NET, Java, Python, and TypeScript. # Aspose.3D FOSS Load, create, transform, and export 3D scenes — free and open-source, available for .NET, Java, Python, and TypeScript. Aspose.3D FOSS is a suite of free, MIT-licensed open-source libraries for loading, building, and exporting 3D scenes, with no native runtime, no external SDK, and no third-party renderer required. Each edition supports OBJ (with MTL materials), STL (binary and ASCII), glTF 2.0 / GLB (PBR materials), COLLADA, 3MF, and FBX with per-format load/save options and round-trip fidelity. Every library in the suite installs with a single package manager command and runs identically on Windows, macOS, Linux, Docker, and serverless. For the enterprise product family, see [Aspose.3D — Enterprise Product Family](https://products.aspose.com/3d/). ## Related Topics - [Aspose.3D FOSS for Java](https://products.aspose.org/3d/java/) - [Aspose.3D FOSS for .NET](https://products.aspose.org/3d/net/) - [Aspose.3D FOSS for Python](https://products.aspose.org/3d/python/) - [Aspose.3D FOSS for TypeScript](https://products.aspose.org/3d/typescript/) --- # Aspose.3D FOSS for Java URL: https://products.aspose.org/3d/java/ Load, create, transform, and export 3D scenes from Java — free and open-source. --- Product: Aspose.3D Platform: java Page Type: index Canonical URL: https://products.aspose.org/3d/java/ --- Aspose.3D FOSS for Java is a free, MIT-licensed library for reading and writing 3D geometry in OBJ, STL, glTF, GLB, and FBX (import) formats from JVM projects. Add a single Maven dependency to get started. # Aspose.3D FOSS for Java Load, create, transform, and export 3D scenes from Java — free and open-source. Aspose.3D FOSS for Java is a MIT-licensed, pure-Java library for working with 3D file formats. Add a single Maven dependency and immediately start reading, constructing, and writing 3D scenes without installing any native runtime, external SDK, or third-party renderer. The library exposes a clean scene-graph API built around `Scene`, `Node`, `Mesh`, `Camera`, and `Transform`, the same conceptual model used by professional 3D tools. Format support includes OBJ (with .mtl material loading), STL (binary and ASCII, roundtrip verified), glTF 2.0 (PBR materials), GLB (binary glTF), and FBX (import only). Per-format load and save options let you control coordinate flipping, scale, normal normalization, and material loading without writing any format-specific parsing code. Aspose.3D FOSS requires Java 21 or later and runs identically on Windows, macOS, and Linux CI runners, Docker containers, and serverless environments. Developers requiring enterprise features and production support can use [Aspose.3D for Java — Enterprise Product](https://products.aspose.com/3d/java/) alongside these open-source libraries. ## Load an OBJ Scene and Export as glTF Add the Maven dependency, then call `Scene.fromFile("model.obj")` to load the OBJ file together with its MTL material definitions. A single `scene.save()` call with a `.gltf` extension writes a glTF 2.0 JSON file, with no format registry or converter object needed. ```java import com.aspose.threed.*; // Load an OBJ file (with .mtl materials) Scene scene = Scene.fromFile("model.obj"); // Export as glTF 2.0 scene.save("model.gltf"); ``` ## Convert STL to glTF with GltfSaveOptions To produce a glTF file with coordinate-system adjustments, pass a `StlLoadOptions` instance with `setFlipCoordinateSystem(true)` when opening the source STL file. The same pattern applies to all per-format load options — swap out the options class for the format you are targeting. ```java import com.aspose.threed.*; Scene scene = new Scene(); StlLoadOptions loadOpts = new StlLoadOptions(); loadOpts.setFlipCoordinateSystem(true); scene.open("mesh.stl", loadOpts); // Save as glTF GltfSaveOptions saveOpts = new GltfSaveOptions(); saveOpts.setPrettyPrint(true); scene.save("mesh.gltf", saveOpts); ``` --- # Aspose.3D FOSS for .NET URL: https://products.aspose.org/3d/net/ Load, create, transform, and export 3D scenes from .NET — free and open-source. --- Product: Aspose.3D Platform: net Page Type: index Canonical URL: https://products.aspose.org/3d/net/ --- Aspose.3D FOSS for .NET is a free, MIT-licensed library for importing, transforming, and exporting 3D scenes in OBJ, STL, glTF, GLB, FBX, Collada, and 3MF formats within .NET applications. Add a single NuGet package to get started. # Aspose.3D FOSS for .NET Load, create, transform, and export 3D scenes from .NET — free and open-source. Aspose.3D FOSS for .NET is a MIT-licensed, pure-C# library for working with 3D file formats. Add a single NuGet package and immediately start reading, constructing, and writing 3D scenes without installing any native runtime, external SDK, or third-party renderer. The library exposes a clean scene-graph API built around `Scene`, `Node`, `Mesh`, `Camera`, and `Transform`, the same conceptual model used by professional 3D tools. Format support includes OBJ (with .mtl material loading), STL (binary and ASCII), glTF 2.0 (PBR materials), GLB (binary glTF), FBX (import and export), Collada, and 3MF. Per-format load and save options let you control coordinate flipping, scale, normal normalization, and material loading without writing any format-specific parsing code. Aspose.3D FOSS targets .NET 10.0 and runs on Windows, macOS, and Linux. There is no native extension to compile and no system package to install. Developers requiring enterprise features and production support can use [Aspose.3D for .NET — Enterprise Product](https://products.aspose.com/3d/net/) alongside these open-source libraries. ## Load an OBJ Scene and Export as glTF Add the NuGet package, then call `Scene.Open("model.obj")` to load the OBJ file together with its MTL material definitions. A single `scene.Save()` call with a `.gltf` extension writes a glTF 2.0 JSON file, with no format registry or converter object needed. ```csharp using Aspose.ThreeD; // Load an OBJ file (with .mtl materials) var scene = new Scene(); scene.Open("model.obj"); // Export as glTF 2.0 scene.Save("model.gltf"); ``` ## Load OBJ with Options and Export as STL Per-format option classes let you control import behaviour. For example, `ObjLoadOptions` lets you toggle coordinate flipping, scale, and material loading. The same pattern applies to all formats — swap out the options class for the format you are targeting. ```csharp using Aspose.ThreeD; using Aspose.ThreeD.Formats; var scene = new Scene(); var opts = new ObjLoadOptions(); opts.FlipCoordinateSystem = true; opts.NormalizeNormal = true; scene.Open("mesh.obj", opts); // Re-export as STL scene.Save("mesh.stl"); ``` --- # Aspose.3D FOSS for Python URL: https://products.aspose.org/3d/python/ Load, create, transform, and export 3D scenes from Python — free and open-source. --- Product: Aspose.3D Platform: python Page Type: index Canonical URL: https://products.aspose.org/3d/python/ --- Aspose.3D FOSS for Python is a free, MIT-licensed library for loading, transforming, and saving 3D scenes in OBJ, STL, glTF, COLLADA, 3MF, and FBX formats in Python scripts and pipelines. Install with pip. # Aspose.3D FOSS for Python Load, create, transform, and export 3D scenes from Python — free and open-source. Aspose.3D FOSS for Python is a MIT-licensed, pure-Python library for working with 3D file formats. Install it with a single pip command and immediately start reading, constructing, and writing 3D scenes without installing any native runtime, external SDK, or third-party renderer. The library exposes a clean scene-graph API built around `Scene`, `Node`, `Mesh`, `Camera`, `Light`, and `Transform`, the same conceptual model used by professional 3D tools. Format support includes OBJ (with .mtl material loading), STL (binary and ASCII, roundtrip verified), glTF 2.0 / GLB (PBR materials), COLLADA (DAE), 3MF, and FBX. Per-format load and save options let you control coordinate flipping, scale, normal normalization, and material loading without writing any format-specific parsing code. Aspose.3D FOSS supports Python 3.7 through 3.12 and runs identically on Windows, macOS, and Linux CI runners, Docker containers, and serverless environments. For enterprise features and support, see [Aspose.3D for Python — Enterprise Product](https://products.aspose.com/3d/python-net/). ## Load an OBJ Scene and Export as glTF Install with pip, then call `Scene.open()` with `ObjLoadOptions` to load the OBJ file together with its MTL material definitions. A single `scene.save()` call with a `.gltf` extension writes a glTF 2.0 JSON file — no format registry or converter object needed. ```python from aspose.threed import Scene from aspose.threed.formats import ObjLoadOptions # Load an OBJ file (with .mtl materials) scene = Scene() scene.open("model.obj", ObjLoadOptions()) # Export as glTF 2.0 scene.save("model.gltf") ``` ## Convert STL to Binary GLB with Coordinate Flipping To produce a compact binary GLB instead of the default JSON glTF, pass a `GltfSaveOptions` instance with `binary_mode = True`. The same pattern applies to coordinate-system adjustments — swap out the options class for the format you are targeting. ```python from aspose.threed import Scene from aspose.threed.formats import GltfSaveOptions scene = Scene() scene.open("mesh.stl") # Save as binary GLB opts = GltfSaveOptions() opts.binary_mode = True scene.save("mesh.glb", opts) ``` --- # Aspose.3D FOSS for TypeScript URL: https://products.aspose.org/3d/typescript/ Load, construct, transform, and export 3D scenes from Node.js — fully typed, open-source, and production-ready with a single npm install. --- Product: Aspose.3D Platform: typescript Page Type: index Canonical URL: https://products.aspose.org/3d/typescript/ --- Aspose.3D FOSS for TypeScript is a free, MIT-licensed library for loading, building, and exporting 3D scenes in OBJ, glTF/GLB, STL, 3MF, FBX, and COLLADA formats. Strong TypeScript types, single runtime dependency. # Aspose.3D FOSS for TypeScript Load, construct, transform, and export 3D scenes from Node.js — fully typed, open-source, and production-ready with a single npm install. Aspose.3D FOSS for TypeScript is a MIT-licensed library for working with 3D file formats in Node.js applications. The package is not yet published to npm -- build it from source and start reading, constructing, and writing 3D scenes in TypeScript immediately, with no native addons to compile, no external SDKs to install, and no renderer required. The library exposes a fully typed scene-graph API built around `Scene`, `Node`, `Entity`, `Mesh`, `Camera`, `Light`, and `Transform`, the same conceptual model used by professional 3D tools. Format support includes OBJ (Wavefront, with .mtl material loading), glTF 2.0 and GLB binary (PBR materials), STL (binary and ASCII, full roundtrip), COLLADA (DAE), 3MF, and FBX. Per-format option classes such as `ObjLoadOptions` and `GltfSaveOptions` give you precise control over coordinate-system orientation, scale, normal normalization, binary vs. JSON output, and material loading. Aspose.3D FOSS targets Node.js 18, 20, and 22+ with TypeScript 5.0+ and compiles to CommonJS. The library ships with strict TypeScript compiler settings (`noImplicitAny`, `strictNullChecks`) so your IDE provides full autocomplete and compile-time safety. Its single runtime dependency, `xmldom`, is installed automatically. For the enterprise product family, see [Aspose.3D — Enterprise Product Family](https://products.aspose.com/3d/). ## Load an OBJ Scene and Export as glTF Install with npm, then use `scene.open()` with `ObjLoadOptions` to load the mesh together with its MTL material file. Both `open()` and `save()` are synchronous — no `await` or Promise chaining is needed. Calling `scene.save()` with a `.gltf` extension writes standard glTF 2.0 JSON — the format is inferred automatically from the file extension. ```typescript import { Scene } from "@aspose/3d"; import { ObjLoadOptions } from "@aspose/3d/formats/obj"; const scene = new Scene(); scene.open("model.obj", new ObjLoadOptions()); // Export as glTF 2.0 JSON scene.save("model.gltf"); ``` ## Convert STL to Binary GLB To produce a compact binary GLB instead of the default JSON glTF, pass `GltfSaveOptions` with `binaryMode = true`. Both `open()` and `save()` are synchronous — no `await` is needed. ```typescript import { Scene } from "@aspose/3d"; import { GltfSaveOptions } from "@aspose/3d/formats/gltf"; const scene = new Scene(); scene.open("mesh.stl"); // Save as compact binary GLB const opts = new GltfSaveOptions(); opts.binaryMode = true; scene.save("mesh.glb", opts); ``` --- # Aspose.BarCode FOSS URL: https://products.aspose.org/barcode/ Generate standards-compliant barcodes across seven symbologies. Open-source, MIT licensed, pure Python with no native dependencies. --- Product: barcode Page Type: index Canonical URL: https://products.aspose.org/barcode/ --- Aspose.BarCode FOSS is a free, open-source library for generating Code 128, Code 39, EAN-13, EAN-8, QR Code, UPC-A, and UPC-E barcodes. MIT licensed, renders to SVG and PNG. # Aspose.BarCode FOSS Generate standards-compliant barcodes across seven symbologies. Open-source, MIT licensed, pure Python with no native dependencies. Aspose.BarCode FOSS is a family of open-source libraries for generating standards-compliant barcodes in your applications. The libraries support Code 128, Code 39, EAN-13, EAN-8, QR Code, UPC-A, and UPC-E symbologies and render output directly to SVG and PNG. Currently available for Python, each library provides a high-level generation API, per-symbology encoding options, and customizable rendering with control over scale, DPI, colors, quiet zone, and human-readable text. All libraries are MIT-licensed and hosted on GitHub. For the enterprise product family, see [Aspose.BarCode — Enterprise Product Family](https://products.aspose.com/barcode/). ## Related Topics - [Aspose.BarCode FOSS for Python](https://products.aspose.org/barcode/python/) --- # Aspose.BarCode FOSS for Python URL: https://products.aspose.org/barcode/python/ Open-source Python library for generating standards-compliant 1D and 2D barcodes. MIT licensed, pure Python, renders to SVG and PNG. --- Product: barcode Platform: python Page Type: index Canonical URL: https://products.aspose.org/barcode/python/ --- Aspose.BarCode FOSS for Python is a free, MIT-licensed library for generating Code 128, Code 39, EAN-13, EAN-8, QR Code, UPC-A, and UPC-E barcodes. Renders to SVG and PNG. Install with pip. # Aspose.BarCode FOSS for Python Open-source Python library for generating standards-compliant 1D and 2D barcodes. MIT licensed, pure Python, renders to SVG and PNG. Aspose.BarCode FOSS for Python is a free, open-source library for generating standards-compliant barcodes in pure Python. The package is not yet published on PyPI — build from source and start creating Code 128, Code 39, EAN-13, EAN-8, QR Code, UPC-A, and UPC-E barcodes. Each barcode renders directly to SVG or PNG with no native dependencies. The library exposes a high-level `generate()` function and per-symbology helpers such as `barcode.code128()`, `barcode.qr()`, and `barcode.ean13()`. Every call returns a `Barcode` object with `.to_svg()` and `.to_png()` methods for immediate output. Rendering options including scale, DPI, module dimensions, colors, quiet zone, and human-readable text visibility are controlled through `RenderOptions`. Because the library is pure Python with no native Office or imaging dependencies, it runs identically on Windows, Linux, and macOS, including Docker containers and CI runners. The codebase is MIT-licensed and hosted on GitHub. For enterprise features and support, see [Aspose.BarCode for Python — Enterprise Product](https://products.aspose.com/barcode/python-net/). ## Generate a Code 128 Barcode Create a Code 128 barcode with the high-level `generate()` function and render it to SVG. ```python import aspose_barcode_foss as barcode bc = barcode.generate("code128", "Hello World") svg_string = bc.to_svg() print(svg_string[:80]) ``` ## Create a QR Code with Custom Options Generate a QR Code with specific error correction and render to PNG bytes. ```python import aspose_barcode_foss as barcode from aspose_barcode_foss import QrOptions, QrErrorCorrectionLevel bc = barcode.qr("https://example.com", options=QrOptions( error_correction_level=QrErrorCorrectionLevel.H )) png_bytes = bc.to_png() with open("qr.png", "wb") as f: f.write(png_bytes) ``` ## Render with Custom Appearance Use `RenderOptions` to control scale, colors, and quiet zone for any barcode. ```python import aspose_barcode_foss as barcode from aspose_barcode_foss import RenderOptions bc = barcode.ean13("590123412345") svg = bc.to_svg(options=RenderOptions( scale=2.0, foreground_color="#003366", quiet_zone=10.0, show_text=True )) ``` --- # Aspose.CAD FOSS URL: https://products.aspose.org/cad/ Read, render, and convert CAD drawings. Open-source, MIT licensed, with no AutoCAD dependency required. --- Product: cad Page Type: index Canonical URL: https://products.aspose.org/cad/ --- Aspose.CAD FOSS is a free, open-source library for reading, rendering, and converting CAD formats like DWG, DXF, and DGN to PDF, SVG, PNG, and more. MIT licensed. # Aspose.CAD FOSS Read, render, and convert CAD drawings. Open-source, MIT licensed, with no AutoCAD dependency required. Aspose.CAD FOSS is coming soon as an open-source library for loading, viewing, and converting CAD drawings like DWG, DXF, DGN, and more. You will be able to export CAD files to formats such as PDF, SVG, PNG, JPG, and TIFF, while keeping layouts, layers, and annotations accurate. The library will also support features like drawing version detection, zoom, rotate, and selective layer rendering. Aspose.CAD FOSS works fully offline and does not need AutoCAD or other CAD software, making it a great fit for server, web, and desktop engineering solutions. For the enterprise product family, see [Aspose.CAD — Enterprise Product Family](https://products.aspose.com/cad/). --- # Aspose.Cells FOSS URL: https://products.aspose.org/cells/ Create, read, modify, and save Excel .xlsx workbooks — free, MIT-licensed, zero Office dependency. Available for .NET, C++, Go, Java, Python, Rust, and TypeScript. --- Product: Aspose.Cells Page Type: index Canonical URL: https://products.aspose.org/cells/ --- Aspose.Cells FOSS is a free, MIT-licensed open-source library for creating, reading, modifying, and saving Excel .xlsx workbooks with no Microsoft Office dependency. Available for .NET, C++, Go, Java, Python, Rust, and TypeScript. # Aspose.Cells FOSS Create, read, modify, and save Excel .xlsx workbooks — free, MIT-licensed, zero Office dependency. Available for .NET, C++, Go, Java, Python, Rust, and TypeScript. Aspose.Cells FOSS is a free, MIT-licensed open-source library for creating, reading, modifying, and saving Excel `.xlsx` workbooks across every supported language binding, with no Microsoft Office installation or native Office libraries required. All language bindings support XLSX round-trip read/write with full cell-data fidelity, formulas, styling, and data validation. Select language bindings additionally provide conditional formatting, auto-filter, export to CSV, JSON, Markdown, and TSV, along with charts, encryption, and hyperlink management. Install with a single package manager command and run on Windows, macOS, Linux, Docker, and serverless environments. For the enterprise product family, see [Aspose.Cells — Enterprise Product Family](https://products.aspose.com/cells/). ## Related Topics - [Aspose.Cells FOSS for C++](https://products.aspose.org/cells/cpp/) - [Aspose.Cells FOSS for Java](https://products.aspose.org/cells/java/) - [Aspose.Cells FOSS for .NET](https://products.aspose.org/cells/net/) - [Aspose.Cells FOSS for Python](https://products.aspose.org/cells/python/) - [Aspose.Cells FOSS for Rust](https://products.aspose.org/cells/rust/) - [Aspose.Cells FOSS for TypeScript](https://products.aspose.org/cells/typescript/) --- # Aspose.Cells FOSS for C++ URL: https://products.aspose.org/cells/cpp/ Open-source C++ library for creating, loading, editing, and saving Excel .xlsx workbooks without Microsoft Excel. --- Product: Aspose.Cells Platform: cpp Page Type: index Canonical URL: https://products.aspose.org/cells/cpp/ --- Open-source C++ library for Excel .xlsx workbooks. Create, edit, style, and save spreadsheets with cells, formulas, and formatting. MIT licensed. # Aspose.Cells FOSS for C++ Open-source C++ library for creating, loading, editing, and saving Excel .xlsx workbooks without Microsoft Excel. Aspose.Cells FOSS for C++ is an open-source library that enables developers to programmatically create, load, edit, and save Excel `.xlsx` workbooks without requiring Microsoft Excel or any COM interop. The library provides a native C++ API that integrates directly into CMake-based build systems with no external runtime dependencies. The core API covers `Workbook` creation and persistence, `Worksheet` and cell manipulation via `Worksheet.GetCells()`, cell value assignment using `Cell.PutValue()`, formula entry with `Cell.SetFormula()`, and rich styling through the `Style`, `Font`, and `Color` classes. Number format display is handled by `DisplayTextFormatter` with full locale support. Named ranges are managed through `DefinedNameUtility` and related collection classes. Aspose.Cells FOSS for C++ is released under the MIT license with no runtime fees or usage restrictions. Build from source using CMake and integrate directly into your project as a header-and-source library. For enterprise features and support, see [Aspose.Cells for C++ — Enterprise Product](https://products.aspose.com/cells/cpp/). ## Create a Styled Workbook and Save as .xlsx Create a workbook, populate cells with values and a formula, apply header styling, and save: ```cpp #include "aspose/cells_foss/Workbook.h" #include "aspose/cells_foss/Worksheet.h" #include "aspose/cells_foss/Cell.h" #include "aspose/cells_foss/Style.h" #include "aspose/cells_foss/Color.h" #include "aspose/cells_foss/Font.h" using namespace Aspose::Cells_FOSS; int main() { Workbook workbook; Worksheet& sheet = workbook.GetWorksheets()[0]; sheet.SetName("Products"); sheet.GetCells()["A1"].PutValue("Product"); sheet.GetCells()["B1"].PutValue("Price"); sheet.GetCells()["A2"].PutValue("Apple"); sheet.GetCells()["B2"].PutValue(2.99); sheet.GetCells()["B4"].SetFormula("=SUM(B2:B3)"); Style headerStyle = sheet.GetCells()["A1"].GetStyle(); Font font; font.SetBold(true); font.SetColor(Color::FromArgb(255, 255, 255, 255)); headerStyle.SetFont(font); headerStyle.SetForegroundColor(Color::FromArgb(255, 34, 120, 212)); sheet.GetCells()["A1"].SetStyle(headerStyle); workbook.Save("products.xlsx"); return 0; } ``` --- # Aspose.Cells FOSS for Java URL: https://products.aspose.org/cells/java/ Open-source Java 17 library for creating, loading, modifying, and saving Excel .xlsx workbooks. --- Product: Aspose.Cells Platform: java Page Type: index Canonical URL: https://products.aspose.org/cells/java/ --- Free Java 17 library to create, load, modify, and save Excel .xlsx workbooks. MIT-licensed, Maven-based. # Aspose.Cells FOSS for Java Open-source Java 17 library for creating, loading, modifying, and saving Excel .xlsx workbooks. Aspose.Cells FOSS for Java is a pure-Java 17 library that enables developers to create, load, modify, and save Excel .xlsx workbooks without any commercial Aspose runtime dependency. It exposes a clean public API under the com.aspose.cells_foss package and is released under the MIT license. The library covers the core spreadsheet object model: workbooks, worksheets, cells, styles, and collections. Supported capabilities include cell values (string, number, boolean, date/time, and formula), cell formatting (fonts, borders, fills, alignment, and number formats), AutoFilters, data validation, conditional formatting, hyperlinks, merged cells, defined names, page setup, and worksheet protection. Aspose.Cells FOSS for Java is built with Maven 3.9+ and targets Java 17+. Add it to your project via a single Maven dependency. Saving is currently limited to the .xlsx format. For enterprise features and support, see [Aspose.Cells for Java — Enterprise Product](https://products.aspose.com/cells/java/). ## Create a Workbook, Write Values, and Save Create a workbook, set cell values and styles, adjust row and column dimensions, and save to an `.xlsx` file using `Workbook.save()`. ```java import com.aspose.cells_foss.Cell; import com.aspose.cells_foss.Style; import com.aspose.cells_foss.Workbook; import com.aspose.cells_foss.Worksheet; public class Main { public static void main(String[] args) { try (Workbook workbook = new Workbook()) { Worksheet sheet = workbook.getWorksheets().get(0); sheet.setName("Report"); sheet.getCells().get("A1").putValue("Revenue"); sheet.getCells().get("B1").putValue(12500.75); Cell total = sheet.getCells().get("B1"); Style style = total.getStyle(); style.getFont().setBold(true); style.setCustom("#,##0.00"); total.setStyle(style); sheet.getCells().getRows().get(0).setHeight(22.0); sheet.getCells().getColumns().get(1).setWidth(14.5); workbook.save("report.xlsx"); } } } ``` ## Load a Workbook with Diagnostics Load an existing `.xlsx` file using `LoadOptions` to enable repair mode, then inspect load diagnostics before saving the modified workbook. ```java import com.aspose.cells_foss.LoadIssue; import com.aspose.cells_foss.LoadOptions; import com.aspose.cells_foss.Workbook; public class LoadWorkbook { public static void main(String[] args) { LoadOptions options = new LoadOptions(); options.setStrictMode(false); options.setTryRepairPackage(true); options.setTryRepairXml(true); try (Workbook workbook = new Workbook("input.xlsx", options)) { if (workbook.getLoadDiagnostics().hasRepairs()) { for (LoadIssue issue : workbook.getLoadDiagnostics().getIssues()) { System.out.println(issue.getMessage()); } } workbook.getDocumentProperties().setAuthor("cells-foss"); workbook.save("output.xlsx"); } } } ``` ## Data Validation and Conditional Formatting Add a whole-number validation rule and highlight qualifying cells with bold conditional formatting in a single workbook. ```java import com.aspose.cells_foss.CellArea; import com.aspose.cells_foss.FormatCondition; import com.aspose.cells_foss.FormatConditionCollection; import com.aspose.cells_foss.FormatConditionType; import com.aspose.cells_foss.OperatorType; import com.aspose.cells_foss.Style; import com.aspose.cells_foss.Validation; import com.aspose.cells_foss.ValidationType; import com.aspose.cells_foss.Workbook; import com.aspose.cells_foss.Worksheet; public class RulesExample { public static void main(String[] args) { try (Workbook workbook = new Workbook()) { Worksheet sheet = workbook.getWorksheets().get(0); int vi = sheet.getValidations().add(new CellArea(1, 0, 10, 1)); Validation validation = sheet.getValidations().get(vi); validation.setType(ValidationType.WHOLE_NUMBER); validation.setOperator(OperatorType.BETWEEN); validation.setFormula1("1"); validation.setFormula2("100"); int cfIndex = sheet.getConditionalFormattings().add(); FormatConditionCollection conditions = sheet.getConditionalFormattings().get(cfIndex); conditions.addArea(CellArea.createCellArea("B2", "B11")); int condIndex = conditions.addCondition( FormatConditionType.CELL_VALUE, OperatorType.BETWEEN, "1", "100"); FormatCondition condition = conditions.get(condIndex); Style style = condition.getStyle(); style.getFont().setBold(true); condition.setStyle(style); workbook.save("rules.xlsx"); } } } ``` --- # Aspose.Cells FOSS for .NET URL: https://products.aspose.org/cells/net/ Create, modify, and save Excel .xlsx workbooks from .NET — free and open-source, zero Microsoft Office dependency. --- Product: Aspose.Cells Platform: net Page Type: index Canonical URL: https://products.aspose.org/cells/net/ --- Aspose.Cells FOSS for .NET is a free, MIT-licensed library for creating, reading, modifying, and saving Excel .xlsx workbooks. No Microsoft Office required. Install with dotnet add package. # Aspose.Cells FOSS for .NET Create, modify, and save Excel .xlsx workbooks from .NET — free and open-source, zero Microsoft Office dependency. Aspose.Cells FOSS for .NET is a free, MIT-licensed open-source library for working with Excel spreadsheet files in .NET applications. Install it with a single `dotnet add package` command and start creating workbooks, reading cells, applying styles, adding conditional formatting, hyperlinks, data validation, and auto-filters — all without requiring Microsoft Excel or any native Office library. The library exposes a clean API built around `Workbook`, `Worksheet`, `Cells`, and `Cell` — the familiar objects every spreadsheet developer knows. Construct a `Workbook` to load an existing `.xlsx` file or create a blank one, access worksheets through the `Worksheets` collection, read and write cell values with `PutValue`, and apply styles via `GetStyle()`/`SetStyle()`. Formulas are stored verbatim as strings and evaluated by the viewer on open, not by the library at runtime. Because the library is pure managed .NET code with no native dependencies, it runs identically on Windows, macOS, Linux, Docker containers, and serverless environments such as Azure Functions and AWS Lambda. The MIT License permits unrestricted commercial use with no royalties, seat licenses, or per-deployment fees. Developers requiring enterprise features and production support can use [Aspose.Cells for .NET — Enterprise Product](https://products.aspose.com/cells/net/) alongside these open-source libraries. ## Create a Workbook and Write Cells Install the NuGet package, then create a `Workbook`, access the first `Worksheet`, and write values to cells using `PutValue`. The example demonstrates writing multiple value types and performing a save-and-reload round trip. ```csharp using Aspose.Cells_FOSS; var outputPath = "cell-data-roundtrip.xlsx"; var workbook = new Workbook(); var sheet = workbook.Worksheets[0]; sheet.Cells["A1"].PutValue("Hello"); sheet.Cells["B1"].PutValue(123); sheet.Cells["C1"].PutValue(true); sheet.Cells["D1"].PutValue(12.5m); sheet.Cells["F1"].PutValue(10); sheet.Cells["G1"].Formula = "=F1*2"; workbook.Save(outputPath); var loaded = new Workbook(outputPath); var loadedSheet = loaded.Worksheets[0]; Console.WriteLine(loadedSheet.Cells["A1"].StringValue); Console.WriteLine(loadedSheet.Cells["G1"].Formula); ``` ## Apply Conditional Formatting Add conditional formatting rules to highlight cell ranges. The example applies a between-value rule with a solid fill, an expression rule, a color scale, a data bar, and an icon set. ```csharp using Aspose.Cells_FOSS; var workbook = new Workbook(); var sheet = workbook.Worksheets[0]; sheet.Name = "Conditional Formatting"; for (var i = 0; i < 10; i++) sheet.Cells[i, 0].PutValue(i + 1); var cfCol = sheet.ConditionalFormattings[sheet.ConditionalFormattings.Add()]; cfCol.AddArea(CellArea.CreateCellArea("A1", "A10")); var rule = cfCol[cfCol.AddCondition(FormatConditionType.CellValue, OperatorType.Between, "3", "7")]; var style = rule.Style; style.Pattern = FillPattern.Solid; style.ForegroundColor = Color.FromArgb(255, 255, 199, 206); style.Font.Bold = true; rule.Style = style; workbook.Save("conditional-formatting.xlsx"); ``` ## Add Hyperlinks and Named Ranges Create external and internal hyperlinks, then define named ranges scoped to the workbook or a specific sheet. ```csharp using Aspose.Cells_FOSS; var workbook = new Workbook(); var sheet = workbook.Worksheets[0]; sheet.Name = "Links"; sheet.Cells["A1"].PutValue("Docs"); var link = sheet.Hyperlinks[sheet.Hyperlinks.Add("A1", 1, 1, "https://example.com/docs")]; link.TextToDisplay = "Docs"; link.ScreenTip = "External docs"; var name = workbook.DefinedNames[workbook.DefinedNames.Add("GlobalRange", "='Links'!$A$1:$D$5")]; name.Comment = "Primary sample range"; workbook.Save("hyperlinks-and-names.xlsx"); ``` --- # Aspose.Cells FOSS for Python URL: https://products.aspose.org/cells/python/ Create, modify, and export Excel spreadsheets from Python — free and open-source, zero Microsoft Office dependency. --- Product: Aspose.Cells Platform: python Page Type: index Canonical URL: https://products.aspose.org/cells/python/ --- Aspose.Cells FOSS for Python is a free, MIT-licensed library for creating, reading, modifying, and exporting Excel spreadsheets to XLSX, CSV, Markdown, and JSON. No Microsoft Office required. Install with pip. # Aspose.Cells FOSS for Python Create, modify, and export Excel spreadsheets from Python — free and open-source, zero Microsoft Office dependency. Aspose.Cells FOSS for Python is a free, open-source library for working with spreadsheet files in Python applications. Install it with a single pip command (see below) and start creating workbooks, reading cells, applying styles, building charts, and exporting to XLSX, CSV, Markdown, or JSON, all without requiring Microsoft Excel or any Office dependency. The library exposes a clean, Pythonic API built around `Workbook`, `Worksheet`, `Cells`, and `Cell`, the familiar objects every spreadsheet developer knows. Read and write cells using bracket notation (`ws.cells["A1"].value = "Hello"`), style them with `Font` and `Fill` objects, and build column or line charts using dedicated `add_bar()` and `add_line()` methods on `ws.charts`. Because the library has no dependency on native Office libraries, it runs identically on Windows, Linux, and macOS CI runners, Docker containers, and serverless environments. The `markitdown-aspose-cells-plugin` package extends Microsoft's MarkItDown library with XLSX support, enabling full workbook-to-Markdown export with a single call. Developers requiring enterprise features and production support can use [Aspose.Cells for Python — Enterprise Product](https://products.aspose.com/cells/python-net/) alongside these open-source libraries. ## Create a Workbook and Write Cells Install with pip, then create a `Workbook`, access the first `Worksheet`, and write values directly to cells using bracket notation. The example also shows how to bold the header row by modifying the cell style before saving. ```python from aspose.cells_foss import Workbook wb = Workbook() ws = wb.worksheets[0] # Write values ws.cells["A1"].value = "Product" ws.cells["B1"].value = "Revenue" ws.cells["A2"].value = "Widget" ws.cells["B2"].value = 42000 # Bold the header row for col in ["A1", "B1"]: style = ws.cells[col].get_style() style.font.bold = True ws.cells[col].apply_style(style) wb.save("report.xlsx") ``` ## Build a Chart and Export to Multiple Formats Open the workbook saved above, add a bar chart over a range of rows, then call `save()` three times with different file extensions — XLSX, Markdown, and CSV — without changing any other code. ```python from aspose.cells_foss import Workbook wb = Workbook("report.xlsx") ws = wb.worksheets[0] # Add a bar chart over rows 2-10 chart = ws.charts.add_bar(12, 0, 25, 6) chart.n_series.add("B2:B10", True) chart.title = "Revenue by Product" wb.save("report_with_chart.xlsx") # Export the same workbook to Markdown wb.save("report.md") # Or export to CSV wb.save("report.csv") ``` --- # Aspose.Cells FOSS for Rust URL: https://products.aspose.org/cells/rust/ Open-source Rust crate for creating, reading, editing, and saving Excel XLSX spreadsheets with no Office dependencies. --- Product: Aspose.Cells Platform: rust Page Type: index Canonical URL: https://products.aspose.org/cells/rust/ --- Open-source Rust crate to create, load, edit, and save Excel XLSX workbooks — cells, formulas, charts, styles, and validation. MIT licensed. # Aspose.Cells FOSS for Rust Open-source Rust crate for creating, reading, editing, and saving Excel XLSX spreadsheets with no Office dependencies. Aspose.Cells FOSS for Rust is an open-source library for working with Excel XLSX spreadsheets in Rust applications. It gives systems programmers a native, memory-safe way to create workbooks from scratch, load existing XLSX files, modify their contents, and save the result — without Microsoft Office, COM automation, or any external runtime. The crate models the full spreadsheet object tree: `Workbook`, `Worksheet`, and cell collections with typed value setters (`put_value_string`, `put_value_i32`, `put_value_bool`, `put_value_decimal`), formulas with cached values via `put_formula_with_cached_value`, charts (`Chart`, `ChartType`), conditional formatting (`FormatCondition`), data validation (`Validation`), auto-filters (`AutoFilter`), cell styling (`CellStyle`, `Font`, `Fill`, `Borders`), page setup (`PageSetup`), pictures, shapes, comments, hyperlinks, tables (`ListObject`), sparklines (`SparklineGroup`), defined names, and workbook/worksheet protection. Aspose.Cells FOSS for Rust is MIT licensed and targets Rust edition 2021. It installs as a standard Cargo dependency from the GitHub repository — see the installation guide for the exact `Cargo.toml` entry. Errors are surfaced through conventional `Result` types (`CellsError`), and XLSX loading offers repair options (`LoadOptions`) with structured diagnostics (`LoadDiagnostics`). For the enterprise product family, see [Aspose.Cells — Enterprise Product Family](https://products.aspose.com/cells/). ## Create, Save, and Reload a Workbook Create a workbook, write typed values and a formula with a cached result, save it as XLSX, and load it back: ```rust use aspose_cells_foss_rust::{CellValue, Workbook}; use std::error::Error; fn main() -> Result> { // Create a new workbook (starts with one sheet, "Sheet1"). let mut workbook = Workbook::new(); { let mut worksheets = workbook.get_worksheets_mut(); let sheet = worksheets.get(0)?; let mut cells = sheet.get_cells_mut(); cells.get("A1")?.put_value_string("Hello")?; cells.get("B1")?.put_value_i32(123)?; cells.get("C1")?.put_value_bool(true)?; cells.get("D1")?.put_value_decimal(12.5)?; cells.get("F1")?.put_value_i32(10)?; cells.get("G1")? .put_formula_with_cached_value("=F1*2", CellValue::Number(20.0))?; } workbook.save("hello.xlsx")?; // Load it back. let loaded = Workbook::load_xlsx("hello.xlsx")?; let sheet = loaded.worksheet("Sheet1")?; let cells = sheet.get_cells(); println!("A1 = {}", cells.get("A1")?.display_string_value()); Ok(()) } ``` ## Load XLSX Files with Repair Options Open workbooks defensively with `LoadOptions` repair flags and inspect structured load diagnostics: ```rust let options = LoadOptions { try_repair_package: true, try_repair_xml: true, ..LoadOptions::default() }; let loaded = Workbook::load_xlsx_with_options(&valid_path, &options)?; let sheet = loaded.worksheet("Sheet1")?; let cells = sheet.get_cells(); println!("Saved: {}", valid_path.display()); println!( "Loaded workbook with {} worksheet(s) and {} diagnostic issue(s).", loaded.get_worksheets().count(), loaded.get_load_diagnostics().issues().len() ); ``` ## Add Charts from Data Ranges Fill a data range, then anchor column and line charts to it: ```rust let mut charts = sheet.get_charts(); charts.add( ChartType::Column, "Charts!$B$1:$B$13".to_string(), 0, 4, 18, 8, )?; charts.add( ChartType::Line, "Charts!$C$1:$C$13".to_string(), 0, 9, 18, 13, )?; ``` --- # Aspose.Cells FOSS for TypeScript URL: https://products.aspose.org/cells/typescript/ Create, modify, and export Excel spreadsheets from TypeScript -- free and open-source, zero Microsoft Office dependency. --- Product: Aspose.Cells Platform: typescript Page Type: index Canonical URL: https://products.aspose.org/cells/typescript/ --- Aspose.Cells FOSS for TypeScript is a free, MIT-licensed library for creating and reading XLSX Excel spreadsheets, with export to XLSX, CSV, Markdown, JSON, and HTML. # Aspose.Cells FOSS for TypeScript Create, modify, and export Excel spreadsheets from TypeScript -- free and open-source, zero Microsoft Office dependency. Aspose.Cells FOSS for TypeScript is a free, open-source library for working with spreadsheet files in TypeScript applications. The package is not yet published — build from source and start creating and reading XLSX workbooks, applying styles, and building charts, all without requiring Microsoft Excel or any Office dependency. Export finished workbooks to XLSX, CSV, Markdown, JSON, or HTML. The library exposes a clean API built around `Workbook`, `Worksheet`, `Cell`, and `Style` -- the familiar objects every spreadsheet developer knows. Read and write cells using `putValue()`, style them with `Style`, `Font`, and `Fill` objects, add charts via `ChartCollection`, and set up data validation, auto-filters, comments, and hyperlinks on any worksheet. For the enterprise product family, see [Aspose.Cells — Enterprise Product Family](https://products.aspose.com/cells/). ## Write Cell Values and Formulas Create a workbook, write different value types to cells, and set formulas that Excel evaluates on open. ```typescript const workbook = new Workbook(); const worksheet = workbook.worksheets[0]!; worksheet.putValue("A1", 42); worksheet.putValue("A2", 3.14159); worksheet.putValue("A3", "Hello World"); const cellA4 = worksheet.getCell2("A4"); cellA4.setFormula("=SUM(A1:A2)"); await workbook.save("output.xlsx"); ``` ## Apply Font Styling Set font name, size, bold, italic, and color on a cell using the `Style` class. ```typescript const workbook = new Workbook(); const worksheet = workbook.worksheets[0]!; const style = new Style(); style.setFontName("Arial"); style.setFontSize(14); style.setBold(true); style.setItalic(true); style.setFontColor("FF0000"); const cell = worksheet.getCell2("A1"); cell.putValue("Styled Text"); cell.setStyle(style); await workbook.save("styled.xlsx"); ``` ## Set Up Auto-Filter Populate a data range and enable auto-filter headers for interactive column filtering in Excel. ```typescript const workbook = new Workbook(); const worksheet = workbook.worksheets[0]!; worksheet.putValue("A1", "Name"); worksheet.putValue("B1", "Age"); worksheet.putValue("C1", "City"); worksheet.putValue("A2", "Alice"); worksheet.putValue("B2", "25"); worksheet.putValue("C2", "New York"); worksheet.putValue("A3", "Bob"); worksheet.putValue("B3", "30"); worksheet.putValue("C3", "London"); worksheet.setAutoFilter("A1:C4"); await workbook.save("filtered.xlsx"); ``` --- # Aspose.Diagram FOSS URL: https://products.aspose.org/diagram/ Create, edit, and convert Visio diagrams programmatically. Open-source, MIT licensed, with no Microsoft Visio required. --- Product: diagram Page Type: index Canonical URL: https://products.aspose.org/diagram/ --- Aspose.Diagram FOSS is a free, open-source Python library for reading and converting Microsoft Visio diagrams. Supports VSD and VSDX input with export to PDF, HTML, SVG, and raster images. # Aspose.Diagram FOSS Create, edit, and convert Visio diagrams programmatically. Open-source, MIT licensed, with no Microsoft Visio required. Aspose.Diagram FOSS is coming soon as a specialized open-source library for creating, editing, and converting Microsoft Visio files such as VSD, VSDX, and VDX, without needing Microsoft Visio. You will be able to work with shapes, connectors, layers, pages, styles, and layouts, making it a good choice for diagram visualization, business process modeling, network diagrams, org charts, and technical drawings. The library will let you load and read existing diagrams, add shapes and links, apply layout algorithms, and export diagrams to PDF, HTML, SVG, or images. It is designed for complete control over Visio content and will work fully offline and across different platforms, making it ideal for adding Visio file support to production apps, cloud tools, or automation workflows. For the enterprise product family, see [Aspose.Diagram — Enterprise Product Family](https://products.aspose.com/diagram/). --- # Aspose.Drawing FOSS URL: https://products.aspose.org/drawing/ Render text, shapes, and images with GDI+-style 2D graphics. Open-source, MIT licensed, and cross-platform. --- Product: drawing Page Type: index Canonical URL: https://products.aspose.org/drawing/ --- Aspose.Drawing for Python enables GDI+-style 2D graphics rendering across platforms. Draw text, shapes, and images using a familiar object model in Python—without depending on Windows-only libraries. # Aspose.Drawing FOSS Render text, shapes, and images with GDI+-style 2D graphics. Open-source, MIT licensed, and cross-platform. Aspose.Drawing FOSS is coming soon as an open-source graphics library that brings GDI+ style drawing to Windows, Linux, and macOS. You will be able to draw shapes, render styled text, and work with images without relying on OS-specific libraries. The library is designed as a replacement for System.Drawing. Aspose.Drawing FOSS is a good fit for building reports, charts, and automated image tools, and it works fully offline for safe, portable graphics rendering. For the enterprise product family, see [Aspose.Drawing — Enterprise Product Family](https://products.aspose.com/drawing/). --- # Aspose.Email FOSS URL: https://products.aspose.org/email/ Read, create, and process Outlook MSG files, CFB containers, and EML messages — free and open-source, available for .NET, C++, and Python. --- Product: Aspose.Email Page Type: index Canonical URL: https://products.aspose.org/email/ --- Aspose.Email FOSS is a free, open-source library for reading, creating, and processing Outlook MSG files, CFB containers, and EML messages. MIT licensed. Available for .NET, C++, and Python. # Aspose.Email FOSS Read, create, and process Outlook MSG files, CFB containers, and EML messages — free and open-source, available for .NET, C++, and Python. Aspose.Email FOSS is a suite of free, MIT-licensed open-source libraries for reading, creating, and processing Microsoft Outlook MSG files, Compound File Binary (CFB) containers, and EML messages, with no Microsoft Outlook dependency and no proprietary runtime required. Each edition provides low-level CFB access for traversing directory entries, reading and writing storage nodes and raw streams, as well as a high-level MAPI API (`MapiMessage`) for creating messages from scratch, reading subjects, bodies, recipients, and attachments, and converting between MSG and EML/MIME formats. Every library in the suite installs with a single package manager command and runs identically on Windows, macOS, Linux, Docker, and serverless. For the enterprise product family, see [Aspose.Email — Enterprise Product Family](https://products.aspose.com/email/). ## Related Topics - [Aspose.Email FOSS for C++](https://products.aspose.org/email/cpp/) - [Aspose.Email FOSS for .NET](https://products.aspose.org/email/net/) - [Aspose.Email FOSS for Python](https://products.aspose.org/email/python/) --- # Aspose.Email FOSS for C++ URL: https://products.aspose.org/email/cpp/ Read, create, and process Outlook MSG files and CFB containers from C++ — free and open-source, no Microsoft Outlook dependency. --- Product: Aspose.Email Platform: cpp Page Type: index Canonical URL: https://products.aspose.org/email/cpp/ --- Aspose.Email FOSS for C++ is a free, MIT-licensed C++ library for reading, creating, and processing Outlook .msg files and Compound File Binary (CFB) containers. No Microsoft Outlook required. Add via CMake `add_subdirectory`. Builds on Windows, Linux, and macOS. # Aspose.Email FOSS for C++ Read, create, and process Outlook MSG files and CFB containers from C++ — free and open-source, no Microsoft Outlook dependency. Aspose.Email FOSS for C++ is a MIT-licensed, open-source C++ library for working with Microsoft Outlook `.msg` files and Compound File Binary (CFB) containers. Include the headers via CMake and immediately start reading, creating, and processing email messages without installing Microsoft Outlook or any proprietary runtime. The library provides two levels of access. At the low level, `cfb_reader` and `cfb_writer` give full control over CFB binary containers — traverse directory entries, read and write storage nodes and stream data, and inspect the raw sector layout. `msg_reader` and `msg_writer` handle the MSG format on top of CFB, exposing MAPI property streams, recipient tables, and attachment sub-storages. At the high level, `mapi_message` lets you create new messages from scratch, read subjects, bodies, recipients, and attachments, and convert between MSG and EML format. The library builds on any platform with a C++17 compiler and has no external dependencies, making it suitable for Windows, Linux, macOS, Docker containers, and embedded systems. Developers requiring enterprise features and production support can use [Aspose.Email for C++ — Enterprise Product](https://products.aspose.com/email/cpp/) alongside these open-source libraries. ## Read Subject from an MSG File Open an Outlook MSG file from a stream and print the subject — no Microsoft Outlook required. ```cpp #include #include #include "aspose/email/foss/msg/mapi_message.hpp" int main() { std::ifstream input("sample.msg", std::ios::binary); auto message = aspose::email::foss::msg::mapi_message::from_stream(input); std::cout #include "aspose/email/foss/msg/mapi_message.hpp" int main() { auto message = aspose::email::foss::msg::mapi_message::create("Hello", "Body"); message.set_sender_name("Alice"); message.set_sender_email_address("alice@example.com"); message.add_recipient("bob@example.com", "Bob"); message.add_attachment("note.txt", std::vector{'a', 'b', 'c'}, "text/plain"); std::ofstream msg_output("hello.msg", std::ios::binary); message.save(msg_output); std::ofstream eml_output("hello.eml", std::ios::binary); message.save_to_eml(eml_output); } ``` --- # Aspose.Email FOSS for .NET URL: https://products.aspose.org/email/net/ Read, create, and process Outlook MSG files, CFB containers, and EML messages from .NET — free and open-source, no Microsoft Outlook dependency. --- Product: Aspose.Email Platform: net Page Type: index Canonical URL: https://products.aspose.org/email/net/ --- Aspose.Email FOSS for .NET is a free, MIT-licensed C# library for reading, creating, and processing Outlook .msg files, Compound File Binary (CFB) containers, and EML messages. No Microsoft Outlook required. Install with dotnet add package. Requires .NET 8.0+. # Aspose.Email FOSS for .NET Read, create, and process Outlook MSG files, CFB containers, and EML messages from .NET — free and open-source, no Microsoft Outlook dependency. Aspose.Email FOSS for .NET is a MIT-licensed, dependency-free C# library for working with Microsoft Outlook `.msg` files, Compound File Binary (CFB) containers, and EML messages. Add a single NuGet package and immediately start reading, creating, and processing email messages without installing Microsoft Outlook or any proprietary runtime. The library provides two levels of access. At the low level, `CfbReader` and `CfbWriter` give full control over CFB binary containers — traverse directory entries, read and write storage nodes and stream data, and inspect the raw sector layout. `MsgReader` and `MsgWriter` handle the MSG format on top of CFB, exposing MAPI property streams, recipient tables, and attachment sub-storages. At the high level, `MapiMessage` lets you create new messages from scratch, read subject, body, sender, and recipients, manage attachments, and convert between MSG and EML format via a built-in MIME implementation. The library targets .NET 8.0 or later and has no native dependencies, making it suitable for Windows, Linux, macOS, Docker containers, and serverless functions. Developers requiring enterprise features and production support can use [Aspose.Email for .NET — Enterprise Product](https://products.aspose.com/email/net/) alongside these open-source libraries. ## Read Subject from an MSG File Open an Outlook MSG file from a stream and print the subject — no Microsoft Outlook required. ```csharp using System.IO; using Aspose.Email.Foss.Msg; using var stream = File.OpenRead("sample.msg"); var message = MapiMessage.FromStream(stream); Console.WriteLine(message.Subject); ``` ## Create and Save an MSG Message Build a complete email with sender, recipient, and attachment, then write it to an MSG file. ```csharp using System.IO; using Aspose.Email.Foss.Msg; var message = MapiMessage.Create("Hello", "Body"); message.SenderName = "Alice"; message.SenderEmailAddress = "alice@example.com"; message.AddRecipient("bob@example.com", "Bob"); using var attachmentStream = new MemoryStream("abc"u8.ToArray()); message.AddAttachment("note.txt", attachmentStream, "text/plain"); using var output = File.Create("hello.msg"); message.Save(output); ``` ## Convert EML to MSG Load a standard `.eml` file and save it as an Outlook `.msg` file using the built-in MIME parser. ```csharp using System.IO; using Aspose.Email.Foss.Msg; using var input = File.OpenRead("message.eml"); var message = MapiMessage.LoadFromEml(input); using var msgOutput = File.Create("message.msg"); message.Save(msgOutput); using var emlOutput = File.Create("roundtrip.eml"); message.SaveToEml(emlOutput); ``` --- # Aspose.Email FOSS for Python URL: https://products.aspose.org/email/python/ Read, create, and write Outlook MSG files from Python — free and open-source, no Microsoft Office required. --- Product: Aspose.Email Platform: python Page Type: index Canonical URL: https://products.aspose.org/email/python/ --- Aspose.Email FOSS for Python is a 100% free, MIT-licensed library for reading and writing Microsoft Outlook MSG files. Supports message properties, attachments, recipients, and email conversion. Install with pip. # Aspose.Email FOSS for Python Read, create, and write Outlook MSG files from Python — free and open-source, no Microsoft Office required. Aspose.Email FOSS for Python is a 100% free, MIT-licensed library that lets you read and write Microsoft Outlook MSG files entirely from Python, with no Microsoft Office, no COM automation, and no proprietary runtime required. It exposes a clean public API based on MAPI concepts (`MapiMessage`, `MapiAttachment`, `MapiRecipient`) backed by a built-in CFB (Compound File Binary) parser written in pure Python. Install with a single `pip install` command. Requires Python 3.10 or later. The library is suitable for email archival scripts, compliance pipelines, migration tools, and any server-side workflow that needs to parse or produce Outlook MSG files without a Microsoft Office dependency. For enterprise features and support, see [Aspose.Email for Python — Enterprise Product](https://products.aspose.com/email/python-net/). ## Load an MSG File and Read Its Properties Install with pip, then pass a file path to `MapiMessage.from_file()` to parse the MSG binary format. Access subject, body, and attachments through the high-level API. ```python from aspose.email_foss.msg import MapiMessage msg = MapiMessage.from_file("message.msg") print(f"Subject: {msg.subject}") print(f"Body: {msg.body}") for att in msg.iter_attachments_info(): print(f"Attachment: {att.storage_name}") ``` ## Create a New MSG File with Attachments Create MSG files from scratch, add recipients and attachments, and save to disk. ```python from aspose.email_foss.msg import MapiMessage msg = MapiMessage.create("Meeting Notes", "Please review attached.") msg.add_recipient("alice@example.com", display_name="Alice") with open("notes.pdf", "rb") as f: msg.add_attachment("notes.pdf", f.read(), mime_type="application/pdf") msg.save("output.msg") ``` --- # Aspose.Finance FOSS URL: https://products.aspose.org/finance/ Process, validate, and convert financial data formats. Open-source, MIT licensed, and ideal for finance and regulatory automation. --- Product: finance Page Type: index Canonical URL: https://products.aspose.org/finance/ --- Aspose.Finance FOSS is a free, open-source library for processing, validating, and converting XBRL, iXBRL, and OFX financial data. MIT licensed. # Aspose.Finance FOSS Process, validate, and convert financial data formats. Open-source, MIT licensed, and ideal for finance and regulatory automation. Aspose.Finance FOSS is coming soon as an open-source library for automating financial documents and data. You will be able to parse, validate, create, and convert formats like XBRL, iXBRL, and OFX. The library will help you build finance apps that meet regulations, connect financial systems, and automate reporting. Aspose.Finance FOSS works fully offline and gives you complete control over financial data, without needing third-party tools or cloud services. For the enterprise product family, see [Aspose.Finance — Enterprise Product Family](https://products.aspose.com/finance/). --- # Aspose.Font FOSS URL: https://products.aspose.org/font/ Load, inspect, convert, and subset font files programmatically. Supports variable fonts, web packaging, and animation preview. Open-source, MIT licensed. --- Product: Aspose.Font Page Type: index Canonical URL: https://products.aspose.org/font/ --- Aspose.Font FOSS is a free, open-source Python library for loading, inspecting, converting, subsetting, and previewing TTF, WOFF, CFF, Type 1, and OpenType font files. Supports variable fonts and animation preview. MIT licensed. # Aspose.Font FOSS Load, inspect, convert, and subset font files programmatically. Supports variable fonts, web packaging, and animation preview. Open-source, MIT licensed. Aspose.Font FOSS is an open-source Python library for loading, inspecting, converting, subsetting, and previewing font files without requiring extra tools or OS font libraries. Read and write TTF, OTF, CFF, Type 1, WOFF, WOFF2, and EOT formats. Variable-font workflows are supported, including axis exploration, named-instance resolution, and HVAR-aware width calculations. The library also provides animation preview generation (PNG, APNG, SVG), font subsetting by codepoints or glyph IDs, and web packaging to emit WOFF2/WOFF bundles with CSS and specimen HTML. The library is MIT licensed and requires no native dependencies — ideal for font design, web font management, and any application that needs programmatic access to font metrics, glyph outlines, and table data. For the enterprise product family, see [Aspose.Font — Enterprise Product Family](https://products.aspose.com/font/). ## Related Topics - [Aspose.Font FOSS for Python](https://products.aspose.org/font/python/) --- # Aspose.Font FOSS for Python URL: https://products.aspose.org/font/python/ Open-source Python library for loading, inspecting, converting, and subsetting TTF, OTF, CFF, WOFF, WOFF2, and EOT font files. --- Product: Aspose.Font Platform: python Page Type: index Canonical URL: https://products.aspose.org/font/python/ --- Free, open-source Python library for font loading, conversion, glyph inspection, subsetting, and variable font previews. MIT licensed. # Aspose.Font FOSS for Python Open-source Python library for loading, inspecting, converting, and subsetting TTF, OTF, CFF, WOFF, WOFF2, and EOT font files. Aspose.Font FOSS for Python is a pure-Python toolkit for loading, inspecting, converting, subsetting, and previewing fonts across TrueType, OpenType, CFF, Type 1, WOFF, WOFF2, and EOT formats. The library runs on Python 3.10 or later and requires no external OS font libraries or native dependencies. The library exposes a clean API for font loading via `FontLoader`, glyph access via `GlyphAccessor`, format conversion via `FontConverter`, web optimization via `FontCleaner`, text-aware subsetting via `FontSubsetter`, and variable font animation via `AnimationPreviewBuilder`. Font metadata such as name, family, style, glyph count, encoding, and metrics is accessible through the `Font` base class without parsing binary tables manually. Aspose.Font FOSS is MIT licensed and installable from PyPI with a single pip install command. It is suitable for font design tooling, web font pipelines, glyph rendering engines, and any Python application that needs to read, transform, or produce font files. For the enterprise product family, see [Aspose.Font — Enterprise Product Family](https://products.aspose.com/font/). ## Load a Font File Open a TrueType or OpenType font from a file path and read its basic metadata. ```python from aspose_font.loader import FontLoader font = FontLoader.open("Roboto-Regular.ttf") print(font.font_name) # e.g. "Roboto" print(font.font_family) # e.g. "Roboto" print(font.num_glyphs) # e.g. 1294 ``` ## Access Glyphs for a Text String Resolve all glyphs for a Unicode code point and inspect their outline paths. ```python from aspose_font.loader import FontLoader font = FontLoader.open("OpenSans-Regular.otf") glyph_id = font.encoding.unicode_to_gid(0x41) # Unicode for A glyph = font.glyph_accessor.get_glyph_by_id(glyph_id) for cmd in glyph.path: print(type(cmd).__name__, cmd) ``` ## Generate a Variable Font Axis Sweep Animation Create an animated APNG that sweeps a variable font axis from start to end value. ```python from aspose_font.loader import FontLoader from aspose_font.animation import AnimationPreviewBuilder font = FontLoader.open("Roboto-VariableFont_wdth,wght.ttf") asset = AnimationPreviewBuilder.build_axis_sweep( font, axis_tag="wdth", start_val=75.0, end_val=100.0, frames=3, fps=10, text="A", size=10.0, bounce=True, ) asset.write_to("roboto-sweep-wdth.png") ``` ## Clean a Font for Web Deployment Strip legacy tables and Mac name records to reduce binary size before web serving. ```python from aspose_font.loader import FontLoader from aspose_font.cleaner import FontCleaner font = FontLoader.open("Roboto-Regular.ttf") cleaned = FontCleaner.clean_for_web(font) # DSIG, FFTM, meta tables removed; Mac platform name records stripped ``` --- # Aspose.GIS FOSS URL: https://products.aspose.org/gis/ Read, edit, convert, and visualize geospatial data. Open-source, MIT licensed, with no GIS software dependency. --- Product: gis Page Type: index Canonical URL: https://products.aspose.org/gis/ --- Aspose.GIS FOSS is a free, open-source library for reading, writing, and converting Shapefile, GeoJSON, KML, GPX, and other geospatial formats. MIT licensed. # Aspose.GIS FOSS Read, edit, convert, and visualize geospatial data. Open-source, MIT licensed, with no GIS software dependency. Aspose.GIS FOSS is coming soon as an open-source library for handling geospatial vector data. You will be able to work with formats like Shapefile, GeoJSON, KML, GPX, and ESRI File Geodatabase, all without needing other GIS software. The library will let you load, edit, and analyze geographic data, transform coordinates, render maps to images, and convert between spatial formats. Aspose.GIS FOSS supports geometry editing, map styling, and different spatial reference systems, making it a practical choice for mapping apps, spatial data tools, and GIS automation. It runs fully offline and cross-platform. For the enterprise product family, see [Aspose.GIS — Enterprise Product Family](https://products.aspose.com/gis/). --- # Aspose.HTML FOSS URL: https://products.aspose.org/html/ Parse HTML into a standards-based DOM, apply CSS stylesheets, and compute styles. Open-source, MIT licensed, available for Python. --- Product: html Page Type: index Canonical URL: https://products.aspose.org/html/ --- Aspose.HTML FOSS provides free, MIT-licensed open-source libraries for parsing HTML into a DOM, applying CSS, computing styles, and handling URLs and encodings. # Aspose.HTML FOSS Parse HTML into a standards-based DOM, apply CSS stylesheets, and compute styles. Open-source, MIT licensed, available for Python. Aspose.HTML FOSS is a family of free, open-source libraries for working with HTML documents. Parse markup into a standards-based document object model, build and modify element trees, attach CSS stylesheets, and resolve computed styles through the cascade — specificity, inline rules, and inheritance included. Lower-level components expose the HTML tokenizer and tree builder directly, alongside WHATWG-style URL parsing, query-string handling, and character-encoding detection for raw byte streams. Every library in the family is MIT licensed and runs fully offline with no browser engine required, behaving the same way on developer machines, CI runners, and server environments. Typical uses include cleaning up and rewriting stored HTML, validating generated markup in automated tests, and processing legacy documents with mixed encodings. For the enterprise product family, see [Aspose.HTML — Enterprise Product Family](https://products.aspose.com/html/). ## Related Topics - [Aspose.HTML FOSS for Python](https://products.aspose.org/html/python/) --- # Aspose.HTML FOSS for Python URL: https://products.aspose.org/html/python/ Parse HTML into a standards-based DOM, apply CSS, and compute styles from Python — free, open-source, and pure Python. --- Product: html Platform: python Page Type: index Canonical URL: https://products.aspose.org/html/python/ --- Free, MIT-licensed Python library for parsing HTML into a DOM, applying CSS stylesheets, computing styles, and parsing URLs. Install with pip. # Aspose.HTML FOSS for Python Parse HTML into a standards-based DOM, apply CSS, and compute styles from Python — free, open-source, and pure Python. Aspose.HTML FOSS for Python is a free, open-source library for working with HTML documents in Python applications. Install it with a single `pip install aspose-html-foss` command and start parsing markup into a document object model, building and modifying element trees, attaching CSS stylesheets, resolving computed styles, and working with URLs and character encodings — all in pure Python with no browser dependency. The library exposes a standards-oriented API built around `HTMLDocument`, `Document`, `Element`, and `CSSStyleSheet`. Parse markup with `HTMLDocument.parse()`, create and connect nodes with `Document.create_element()` and `append_child()`, look elements up with `get_element_by_id()`, style them through `CSSStyleSheet.replace_sync()` and the element-level `style` declaration, and read the result back with `Element.get_computed_style()`. Lower-level building blocks — the HTML `Tokenizer`, the `TreeBuilder`, WHATWG-style `URL` and `URLSearchParams`, and the `detect_encoding()` byte-stream detector — are available when you need direct control. Aspose.HTML FOSS is MIT licensed and implemented in pure Python, requiring Python 3.10 or later. It runs identically on Windows, Linux, and macOS — including CI runners, Docker containers, and serverless environments. For the enterprise product family, see [Aspose.HTML — Enterprise Product Family](https://products.aspose.com/html/). ## Build a DOM and Resolve the CSS Cascade Create a document, attach a stylesheet, and read the computed style — the ID selector wins over the class rule: ```python from aspose_html.dom import Document from aspose_html.cssom import CSSStyleSheet doc = Document() el = doc.create_element("div") el.set_attribute("class", "foo") el.set_attribute("id", "bar") doc.append_child(el) sheet = CSSStyleSheet() sheet.replace_sync(".foo { color: red } #bar { color: blue }") doc.attach_style_sheet(sheet) style = el.get_computed_style() print(style.get_property_value("color")) ``` ## Inline Styles Take Priority Inline declarations carry higher specificity than author stylesheet rules: ```python from aspose_html.dom import Document from aspose_html.cssom import CSSStyleSheet doc = Document() el = doc.create_element("div") doc.append_child(el) sheet = CSSStyleSheet() sheet.replace_sync("div { color: red }") doc.attach_style_sheet(sheet) inline = el.style inline.set_property("color", "blue") print(el.get_computed_style().get_property_value("color")) ``` ## Detect Character Encoding from Bytes Sniff the encoding of a raw byte stream, BOM included, and get decoded text back: ```python from aspose_html.encoding.detection import detect_encoding result = detect_encoding(b"\xef\xbb\xbfx") print(result.encoding) print(result.confidence) print(result.text) ``` --- # Aspose.Imaging FOSS URL: https://products.aspose.org/imaging/ Create, edit, and convert images across raster and vector formats. Open-source, MIT licensed, with no external tools required. --- Product: imaging Page Type: index Canonical URL: https://products.aspose.org/imaging/ --- Aspose.Imaging FOSS is a free, open-source library for image creation, editing, and conversion across raster and vector formats. MIT licensed. # Aspose.Imaging FOSS Create, edit, and convert images across raster and vector formats. Open-source, MIT licensed, with no external tools required. Aspose.Imaging FOSS is coming soon as an open-source library for working with images across web apps, graphics editors, document processing, and scientific tools. You will be able to load, modify, and save popular raster and vector formats, including BMP, PNG, JPEG, TIFF, GIF, PSD, SVG, EMF, and WMF. The library will cover essential tasks like resizing, cropping, rotating, watermarking, format conversion, and batch processing. Advanced features such as color correction, dithering, multi-page editing for TIFF, and working with layers and frames in GIF or PSD will also be included. Aspose.Imaging FOSS is being ported from the trusted .NET SDK. It will help you add fast, efficient imaging features to your applications, whether for server scripts, desktop tools, or data workflows. Watch for its release soon. For the enterprise product family, see [Aspose.Imaging — Enterprise Product Family](https://products.aspose.com/imaging/). --- # Open Source File Format Libraries for Every Platform URL: https://products.aspose.org/ Browse Aspose FOSS open-source libraries by product: free, MIT-licensed document processing for Python, .NET, Java, TypeScript, C++, and more. --- Product: Aspose Page Type: index Canonical URL: https://products.aspose.org/ --- # Open Source File Format Libraries for Every Platform Free, MIT-licensed open source libraries for file format processing across Python, TypeScript, JavaScript, .NET, Java, Go, PHP, C++, and more. Drop-in SDKs for documents, spreadsheets, presentations, 3D, and beyond. MIT-licensed SDKs for working with documents, spreadsheets, presentations, 3D models, and more — available for Python, TypeScript, JavaScript, .NET, Java, Go, PHP, C++, and other popular platforms. We are expanding the Aspose FOSS ecosystem to cover every major platform and language. Expect dedicated open source libraries for .NET, Java, C++, Go, PHP, JavaScript, and beyond — bringing the same MIT-licensed, no-dependency philosophy to your language of choice. Browse Aspose FOSS open-source libraries by product: free, MIT-licensed document processing for Python, .NET, Java, TypeScript, C++, and more. ## Related Topics - [Aspose.3D FOSS](https://products.aspose.org/3d/) - [Aspose.BarCode FOSS](https://products.aspose.org/barcode/) - [Aspose.CAD FOSS](https://products.aspose.org/cad/) - [Aspose.Cells FOSS](https://products.aspose.org/cells/) - [Aspose.Diagram FOSS](https://products.aspose.org/diagram/) - [Aspose.Drawing FOSS](https://products.aspose.org/drawing/) - [Aspose.Email FOSS](https://products.aspose.org/email/) - [Aspose.Finance FOSS](https://products.aspose.org/finance/) - [Aspose.Font FOSS](https://products.aspose.org/font/) - [Aspose.GIS FOSS](https://products.aspose.org/gis/) - [Aspose.HTML FOSS](https://products.aspose.org/html/) - [Aspose.Imaging FOSS](https://products.aspose.org/imaging/) - [Aspose.Medical FOSS](https://products.aspose.org/medical/) - [Aspose.Note FOSS](https://products.aspose.org/note/) - [Aspose.OCR FOSS](https://products.aspose.org/ocr/) - [Aspose.OMR FOSS](https://products.aspose.org/omr/) - [Aspose.Page FOSS](https://products.aspose.org/page/) - [Aspose.PDF FOSS](https://products.aspose.org/pdf/) - [Aspose.PSD FOSS](https://products.aspose.org/psd/) - [Aspose.PUB FOSS](https://products.aspose.org/pub/) - [Aspose.Slides FOSS](https://products.aspose.org/slides/) - [Aspose.SVG FOSS](https://products.aspose.org/svg/) - [Aspose.Tasks FOSS](https://products.aspose.org/tasks/) - [Aspose.TeX FOSS](https://products.aspose.org/tex/) - [Aspose.Words FOSS](https://products.aspose.org/words/) - [Aspose.ZIP FOSS](https://products.aspose.org/zip/) --- # Aspose.Medical FOSS URL: https://products.aspose.org/medical/ Parse and convert DICOM, HL7, and CDA health data. Open-source, MIT licensed, and HIPAA-aware. --- Product: medical Page Type: index Canonical URL: https://products.aspose.org/medical/ --- Aspose.Medical FOSS is a free, open-source library for working with DICOM images, HL7 messages, and healthcare data formats. MIT licensed. # Aspose.Medical FOSS Parse and convert DICOM, HL7, and CDA health data. Open-source, MIT licensed, and HIPAA-aware. Aspose.Medical FOSS brings healthcare-specific data handling to your applications. It provides a unified API to read, validate, and transform common medical formats such as DICOM (for imaging), HL7 (for clinical messaging), and CDA (Clinical Document Architecture). Designed with HIPAA-compliance, interoperability, and performance in mind, the SDK supports developers building imaging systems, patient management software, EHR integrations, and healthcare analytics platforms. From extracting diagnostic images to parsing patient data, Aspose.Medical helps automate secure medical data workflows. The library is fully offline, cross-platform, and open-source, ensuring flexibility and privacy in sensitive clinical environments. For the enterprise product family, see [Aspose.Medical — Enterprise Product Family](https://products.aspose.com/medical/). --- # Aspose.Note FOSS URL: https://products.aspose.org/note/ Read, convert, and process Microsoft OneNote files, free and open-source, with no Microsoft Office required. --- Product: Aspose.Note Page Type: index Canonical URL: https://products.aspose.org/note/ --- Aspose.Note FOSS is a free, open-source library for reading, converting, and processing Microsoft OneNote (.one) files. MIT licensed. Available for Python. # Aspose.Note FOSS Read, convert, and process Microsoft OneNote files, free and open-source, with no Microsoft Office required. Aspose.Note FOSS is a suite of free, MIT-licensed open-source libraries for reading and processing Microsoft OneNote (.one) files, with no Microsoft Office, no COM automation, and no proprietary runtime required. Each edition reads and traverses the full OneNote document model: pages, outlines, rich text, images, tables, and attachments. Every library in the suite installs with a single package manager command and runs identically on Windows, Linux, macOS, Docker, and serverless. For the enterprise product family, see [Aspose.Note — Enterprise Product Family](https://products.aspose.com/note/). ## Related Topics - [Aspose.Note FOSS for Python](https://products.aspose.org/note/python/) --- # Aspose.Note FOSS for Python URL: https://products.aspose.org/note/python/ Read, traverse, and export Microsoft OneNote (.one) files from Python — free and open-source, no Microsoft Office required. --- Product: Aspose.Note Platform: python Page Type: index Canonical URL: https://products.aspose.org/note/python/ --- Aspose.Note FOSS for Python is a 100% free, MIT-licensed library for reading Microsoft OneNote .one files. Provides text extraction, image export, table parsing, attachment saving, and PDF export. Install with pip. # Aspose.Note FOSS for Python Read, traverse, and export Microsoft OneNote (.one) files from Python — free and open-source, no Microsoft Office required. Aspose.Note FOSS for Python is a 100% free, MIT-licensed library that lets you read Microsoft OneNote (.one) files entirely from Python, with no Microsoft Office, no COM automation, and no proprietary runtime required. It exposes a clean public API (`aspose.note.*`) modeled on the familiar Aspose.Note for .NET interface, backed by a built-in MS-ONE/OneStore binary parser written in pure Python. Install from PyPI (add the `[pdf]` extra to enable PDF export). Requires Python 3.10 or later. The library is suitable for document automation scripts, content indexing pipelines, archival tools, and any server-side workflow that needs to consume OneNote content without a Microsoft Office dependency. For the enterprise product family, see [Aspose.Note — Enterprise Product Family](https://products.aspose.com/note/). ## Load a OneNote File and Extract All Text Install with pip, then pass a file path to `Document()` to parse the OneNote binary format. `GetChildNodes(RichText)` performs a deep recursive search and returns every text node in the document, which is useful for full-text indexing or migration pipelines. ```python from aspose.note import Document, RichText doc = Document("notebook.one") print(f"Pages: {len(list(doc))}") # Extract all text across the entire document texts = [rt.Text for rt in doc.GetChildNodes(RichText) if rt.Text] for text in texts: print(text) ``` ## Export to PDF and Save Attached Images PDF export requires the optional ReportLab dependency, added via the `[pdf]` extra. The same `Document` object can also be iterated for `Image` nodes to extract and save all embedded images to disk in one pass. ```python from aspose.note import Document, SaveFormat, Image import pathlib doc = Document("notebook.one") # Export the document to PDF (requires aspose-note[pdf]) doc.Save("output.pdf", SaveFormat.Pdf) # Save all embedded images to disk out_dir = pathlib.Path("images") out_dir.mkdir(exist_ok=True) for i, img in enumerate(doc.GetChildNodes(Image)): name = img.FileName or f"image_{i}.bin" (out_dir / name).write_bytes(img.Bytes) ``` --- # Aspose.OCR FOSS URL: https://products.aspose.org/ocr/ Extract text from scanned images, PDFs, and photos. Open-source, MIT licensed, and ideal for automation and digitization. --- Product: ocr Page Type: index Canonical URL: https://products.aspose.org/ocr/ --- Aspose.OCR FOSS is a free, open-source library for extracting text from images, scans, and photos with high accuracy. MIT licensed. # Aspose.OCR FOSS Extract text from scanned images, PDFs, and photos. Open-source, MIT licensed, and ideal for automation and digitization. Aspose.OCR FOSS is coming soon as an open-source library for adding advanced text recognition to your applications. It will convert scanned documents, photos, and screenshots into machine-readable text, supporting many image formats and use cases like invoice automation and digitizing archives. Its engine uses machine learning to recognize text accurately, even from skewed, noisy, or low-resolution images, and can extract text from whole pages or selected regions. Aspose.OCR FOSS will work completely offline and fit easily into any backend, AI pipeline, or scanning tool. With its open-source model, developers can customize and contribute to the project, making it a flexible solution for teams that want control over their OCR workflow without extra licensing fees. For the enterprise product family, see [Aspose.OCR — Enterprise Product Family](https://products.aspose.com/ocr/). --- # Aspose.OMR FOSS URL: https://products.aspose.org/omr/ Design and recognize OMR forms from scanned images. Open-source, MIT licensed, and ideal for grading, surveys, and elections. --- Product: omr Page Type: index Canonical URL: https://products.aspose.org/omr/ --- Aspose.OMR FOSS is a free, open-source library for designing and recognizing OMR forms like tests, surveys, and ballots from scanned images. MIT licensed. # Aspose.OMR FOSS Design and recognize OMR forms from scanned images. Open-source, MIT licensed, and ideal for grading, surveys, and elections. Aspose.OMR FOSS is coming soon as an open-source library that will make optical mark recognition easy to add to your projects. You will be able to create custom OMR sheets for tasks like multiple-choice tests, answer sheets, surveys, and ballots, and then read marks from scanned or photographed images. The library will support modern image formats and use noise-tolerant algorithms for accurate results, even with low-quality or mobile photos. Developers can automate the full OMR workflow, from designing forms to extracting results, without the need for advanced image processing or machine learning skills. For the enterprise product family, see [Aspose.OMR — Enterprise Product Family](https://products.aspose.com/omr/). --- # Aspose.Page FOSS URL: https://products.aspose.org/page/ Export PostScript, EPS, and XPS documents to PDF and raster images. Free, MIT-licensed, no Adobe or Ghostscript required. --- Product: Aspose.Page Page Type: index Canonical URL: https://products.aspose.org/page/ --- Aspose.Page FOSS is a free, MIT-licensed library for exporting PostScript, EPS, and XPS documents to PDF and raster images. No Adobe or Ghostscript required. # Aspose.Page FOSS Export PostScript, EPS, and XPS documents to PDF and raster images. Free, MIT-licensed, no Adobe or Ghostscript required. Aspose.Page FOSS is a free, open-source library for converting PostScript (PS), Encapsulated PostScript (EPS), and XPS documents to PDF and raster images. Install with a single command and start exporting documents without any proprietary runtime or system dependency. The library exposes a clean, high-level API for PS/EPS documents through `PsDocument` and for XPS documents through `XpsDocument`. Load a document with `from_file()` or `from_bytes()`, then call `to_pdf()` to obtain a PDF byte stream or `to_image()` with an `ImageSaveOptions` instance to render to PNG or JPEG at a specified DPI. An optional MCP server exposes conversion functions as remote tools using FastMCP, making the library callable from AI agent pipelines and microservices. Because the library has no dependency on Ghostscript, Adobe libraries, or any native Office runtime, it runs identically on Windows, Linux, and macOS, including CI runners and Docker containers. The codebase is MIT-licensed and hosted on GitHub. For the enterprise product family, see [Aspose.Page — Enterprise Product Family](https://products.aspose.com/page/). ## Related Topics - [Aspose.Page FOSS for Python](https://products.aspose.org/page/python/) --- # Aspose.Page FOSS for Python URL: https://products.aspose.org/page/python/ Free, MIT-licensed Python library to export PS, EPS, and XPS documents as PDF and raster images. No Office required. --- Product: Aspose.Page Platform: python Page Type: index Canonical URL: https://products.aspose.org/page/python/ --- Aspose.Page FOSS for Python is a free, MIT-licensed library for exporting PostScript, EPS, and XPS files as PDF and PNG/JPEG. Install with pip. No Office required. # Aspose.Page FOSS for Python Free, MIT-licensed Python library to export PS, EPS, and XPS documents as PDF and raster images. No Office required. Aspose.Page FOSS for Python is a free, open-source library for converting PostScript (PS), Encapsulated PostScript (EPS), and XPS documents in Python applications. See the install section below to get started exporting documents to PDF and raster images without any proprietary runtime or system dependency. The library exposes a clean API built around `PsDocument` and `XpsDocument`. Load a document with `from_file()` or `from_bytes()`, then call `to_pdf()` to obtain a PDF byte stream, or `to_image()` with an `ImageSaveOptions` instance to render to PNG or JPEG at a specified DPI. An optional MCP server exposes `ps_to_pdf`, `ps_to_image`, `xps_to_pdf`, and `xps_to_image` as remote conversion tools using FastMCP. Because the library has no dependency on native Office libraries or Ghostscript, it runs identically on Windows, Linux, and macOS, including CI runners and Docker containers. The codebase is MIT-licensed and hosted on GitHub. Developers who need the full commercial API can use Aspose.Page for Python alongside these open-source resources. For the enterprise product, see [Aspose.Page for Python — Enterprise Product](https://products.aspose.com/page/python-net/). ## Convert PS to PDF Call `PsDocument.from_file()` to access the PostScript file and call `to_pdf()` to export it as a PDF byte stream. ```python from pathlib import Path from aspose.page.ps.document import PsDocument ps = PsDocument.from_file("input.ps") output_pdf = ps.to_pdf() Path("output.pdf").write_bytes(output_pdf) ``` ## Convert EPS to PNG The same `PsDocument` class handles EPS files. Pass an `ImageSaveOptions` with the desired format and DPI to `to_image()`. ```python from aspose.page.ps.document import PsDocument from aspose.page.ps.output import ImageSaveOptions eps = PsDocument.from_file("input.eps") output_png = eps.to_image(ImageSaveOptions(format="png", dpi=150)) with open("output.png", "wb") as f: f.write(output_png) ``` ## Convert XPS to PDF Call `XpsDocument.from_file()` to access the XPS document and call `to_pdf()` to export it as a PDF byte stream. ```python from pathlib import Path from aspose.page.xps.document import XpsDocument xps = XpsDocument.from_file("input.xps") output_pdf = xps.to_pdf() Path("output.pdf").write_bytes(output_pdf) ``` --- # Aspose.PDF FOSS URL: https://products.aspose.org/pdf/ Create, edit, split, merge, encrypt, and render PDF documents to raster images. MIT-licensed open-source libraries for .NET, C++, Go, Java, Python, and TypeScript with no runtime fees. --- Product: Aspose.PDF Page Type: index Canonical URL: https://products.aspose.org/pdf/ --- MIT-licensed open-source PDF libraries for .NET, C++, Go, Java, Python, and TypeScript. Create, edit, split, merge, encrypt, and render PDF documents to raster images. No runtime fees or usage restrictions. # Aspose.PDF FOSS Create, edit, split, merge, encrypt, and render PDF documents to raster images. MIT-licensed open-source libraries for .NET, C++, Go, Java, Python, and TypeScript with no runtime fees. Aspose.PDF FOSS is a suite of open-source libraries for working with PDF documents at every stage of their lifecycle. The libraries support creating new documents from scratch, reading and editing existing files, splitting PDFs into individual page documents, and merging multiple PDFs into a single file. Encryption with AES-128, AES-256, and RC4-128 protects documents with user and owner passwords. AcroForm handling covers the complete set of interactive form field types including text boxes, checkboxes, radio buttons, combo boxes, and button fields. Bookmark (outline) trees can be created and edited, linking entries to target pages with bold and italic styling. Annotation support spans text, link, highlight, freetext, circle, caret, file-attachment, and stamp annotations. Images can be embedded and extracted on a per-page basis. Page rendering converts individual PDF pages to raster images in TIFF format at a configurable DPI, with BMP, JPEG, and PNG available on select platform editions. Full-text search locates all occurrences of a query string across the document, returning matched text and page index. Document metadata (title, author, subject, keywords, creator, producer, creation and modification dates) can be read and updated. Form flattening bakes all interactive field values into static page graphics, producing a non-editable copy. Aspose.PDF FOSS is released under the MIT license with no runtime fees or usage restrictions. For the enterprise product family, see [Aspose.PDF — Enterprise Product Family](https://products.aspose.com/pdf/). ## Related Topics - [Aspose.PDF FOSS for C++](https://products.aspose.org/pdf/cpp/) - [Aspose.PDF FOSS for Java](https://products.aspose.org/pdf/java/) - [Aspose.PDF FOSS for .NET](https://products.aspose.org/pdf/net/) - [Aspose.PDF FOSS for Python](https://products.aspose.org/pdf/python/) - [Aspose.PDF FOSS for TypeScript](https://products.aspose.org/pdf/typescript/) --- # Aspose.PDF FOSS for C++ URL: https://products.aspose.org/pdf/cpp/ Open-source C++ library for creating, editing, rendering, and securing PDF documents with zero runtime dependencies. --- Product: Aspose.PDF Platform: cpp Page Type: index Canonical URL: https://products.aspose.org/pdf/cpp/ --- Open-source C++20 PDF library. Create, edit, extract text, render to raster images, and encrypt PDF documents. MIT licensed, zero dependencies. # Aspose.PDF FOSS for C++ Open-source C++ library for creating, editing, rendering, and securing PDF documents with zero runtime dependencies. Aspose.PDF FOSS for C++ is an open-source, modern C++20 library for working with PDF documents — opening and saving PDFs, extracting text, rasterising pages to image formats, and building documents from scratch (text, images, tables, vector graphics, annotations, AcroForm fields, and bookmarks). The library links against nothing but the C++ standard library: every primitive, including the TIFF, JPEG, and PNG codecs and the page rasteriser, is implemented from scratch with no dependency on any commercial PDF stack. The core API is built around the `Document` class and its `Pages()` collection. Text is extracted with `Aspose::Pdf::Text::TextAbsorber`, pages are rendered to raster images via device classes such as `PngDevice`, `JpegDevice`, `BmpDevice`, and `TiffDevice`, and documents can be secured with `Document.Encrypt()` using RC4-40, RC4-128, AES-128, or AES-256 algorithms selected through the `CryptoAlgorithm` enum. Interactive form fields are managed through the `Form` class, and annotations — text notes, highlights, shapes, and stamps — are added and modified through the `Annotation` class hierarchy. Aspose.PDF FOSS for C++ is released under the MIT license with no runtime fees or usage restrictions. It builds as a static library via CMake — add it as a subdirectory of your build or install it standalone — and requires a C++20 compiler with no other runtime dependencies. For enterprise features and support, see [Aspose.PDF for C++ — Enterprise Product](https://products.aspose.com/pdf/cpp/). ## Open a PDF, Extract Text, and Render a Page Add the library as a CMake subdirectory, then open a document, count its pages, extract text with `TextAbsorber`, and render page 1 to PNG at 150 DPI. ```cmake add_subdirectory(aspose.pdf-foss-for-cpp) target_link_libraries(your_app PRIVATE aspose_pdf_foss) ``` ```cpp #include #include #include #include #include #include #include int main() { Aspose::Pdf::Document doc("input.pdf"); std::cout int main() { Aspose::Pdf::Document doc("input.pdf"); doc.Encrypt("user-password", "owner-password", Aspose::Pdf::Permissions(), Aspose::Pdf::CryptoAlgorithm::AESx256); doc.Save("encrypted.pdf"); } ``` ## Read and Update Document Metadata Read existing `/Info` entries and update the document title through `DocumentInfo`. ```cpp #include #include #include int main() { Aspose::Pdf::Document doc("input.pdf"); auto& info = doc.Info(); std::cout << "Title: " << info.Title() << "\n"; std::cout << "Author: " << info.Author() << "\n"; doc.SetTitle("Updated Report Title"); doc.Save("output.pdf"); } ``` --- # Aspose.PDF FOSS for Java URL: https://products.aspose.org/pdf/java/ Create and manipulate PDF documents from Java — with annotations, form fields, page manipulation, and PDF/A compliance. MIT-licensed. --- Product: Aspose.PDF Platform: java Page Type: index Canonical URL: https://products.aspose.org/pdf/java/ --- Aspose.PDF FOSS for Java is a free, MIT-licensed Java library for creating and working with PDF documents. Includes annotation, form field, and PDF/A compliance features. Requires Java 11+. # Aspose.PDF FOSS for Java Create and manipulate PDF documents from Java — with annotations, form fields, page manipulation, and PDF/A compliance. MIT-licensed. Aspose.PDF FOSS for Java is a MIT-licensed Java library for creating and working with PDF documents. It provides a comprehensive `Document` class as the central entry point, along with full coverage of annotations, interactive form fields, page manipulation, metadata, and PDF/A compliance validation. The library exposes 527 classes covering the full PDF specification: document structure via `Document`, `Page`, and `PageCollection`; annotations through the `Annotation` hierarchy (including `WidgetAnnotation`, `FreeTextAnnotation`, and `HighlightAnnotation`); interactive forms with `Form`, `ButtonField`, `CheckboxField`, and `RadioButtonField`; page rendering via `BmpDevice`; and PDF/A compliance checking through `ActionRules` and `ActionFixes`. Encryption is provided via `AESCipher` in CBC mode. Add Aspose.PDF FOSS to your Maven project using groupId `org.aspose` and artifactId `aspose-pdf-foss`. The library requires Java 11 or later and is fully MIT-licensed. For enterprise features and support, see [Aspose.PDF for Java — Enterprise Product](https://products.aspose.com/pdf/java/). ## Create a Document with Widget Annotation Create a new document, add a page, and attach a widget annotation with styling. ```java try (Document doc = new Document()) { Page page = doc.getPages().add(); WidgetAnnotation w = new WidgetAnnotation(page, new Rectangle(0, 0, 100, 50)); w.getCharacteristics().setBorder(Color.fromRgb(1, 0, 0)); w.getCharacteristics().setCaption("Submit"); page.getAnnotations().add(w); doc.save("output.pdf"); } ``` ## Create a Form with Radio Buttons Add a radio button group to a document form and select a value programmatically. ```java try (Document doc = new Document()) { Page page = doc.getPages().add(); RadioButtonField radio = new RadioButtonField(page); radio.setPartialName("choice"); radio.addOption("Option1", new Rectangle(50, 50, 70, 70)); radio.addOption("Option2", new Rectangle(50, 80, 70, 100)); doc.getForm().add(radio, 1); radio.setValue("Option2"); doc.save("form.pdf"); } ``` ## Inspect Document Page Dimensions Access an existing document and read the media box dimensions of the first page. ```java try (Document doc = new Document("input.pdf")) { double width = doc.getPages().get(1).getMediaBox().getWidth(); double height = doc.getPages().get(1).getMediaBox().getHeight(); System.out.println("Page size: " + width + " x " + height); } ``` --- # Aspose.PDF FOSS for .NET URL: https://products.aspose.org/pdf/net/ Create and manipulate PDF documents from .NET — with annotations, form fields, text extraction, page management, encryption, and HTML/SVG/Markdown import. MIT-licensed. --- Product: Aspose.PDF Platform: net Page Type: index Canonical URL: https://products.aspose.org/pdf/net/ --- Aspose.PDF FOSS for .NET is a free, MIT-licensed library for creating and working with PDF documents in C# and .NET. Includes annotation, form fields, text extraction, document encryption, and HTML/SVG/Markdown import. # Aspose.PDF FOSS for .NET Create and manipulate PDF documents from .NET — with annotations, form fields, text extraction, page management, encryption, and HTML/SVG/Markdown import. MIT-licensed. Aspose.PDF FOSS for .NET is a MIT-licensed library for creating and working with PDF documents in C# and .NET. The central entry point is the `Document` class, which supports construction from file path, byte array, stream, or password-protected sources, and exposes `Open`, `Save`, `Merge`, `Encrypt`, `Decrypt`, and `Convert` operations across the full PDF specification. The library exposes 805 classes covering document structure via `Document`, `Page`, and `PageCollection`; rich annotations through `AnnotationCollection` (including `AddTextAnnotation`, `AddLinkAnnotation`, `AddHighlightAnnotation`, `AddWatermarkAnnotation`, and `AddRedactAnnotation`); interactive forms with `Form`, `ButtonField`, `CheckboxField`, `RadioButtonField`, and `ChoiceField`; text extraction and search via `TextFragmentAbsorber` and `TextFragment`; table detection with `AbsorbedTable`, `AbsorbedRow`, and `AbsorbedCell`; and document security via `Document.Encrypt` and `Document.Decrypt`. Format conversion supports HTML, SVG, and Markdown import alongside PDF export. The library is fully MIT-licensed with no runtime fees or usage restrictions. For enterprise features and support, see [Aspose.PDF for .NET — Enterprise Product](https://products.aspose.com/pdf/net/). ## Open a PDF, Add a Link Annotation, and Save Open an existing PDF, attach a URI link annotation to page 1, and persist the result. ```csharp using Aspose.Pdf; var data = System.IO.File.ReadAllBytes("input.pdf"); using var doc = Document.Open(data); var page = doc.Pages[1]; var action = PdfAction.CreateUri("https://aspose.com"); page.Annotations.AddLinkAnnotation( new Rectangle(50, 700, 200, 720), action); using var ms = new System.IO.MemoryStream(); doc.Save(ms); System.IO.File.WriteAllBytes("output.pdf", ms.ToArray()); ``` ## Add a Watermark Annotation Stamp a watermark onto page 1 of an existing document and round-trip through serialization. ```csharp using Aspose.Pdf; var input = System.IO.File.ReadAllBytes("report.pdf"); using var doc = Document.Open(input); doc.Pages[1].Annotations.AddWatermarkAnnotation( new Rectangle(0, 0, 612, 792), "CONFIDENTIAL"); var saved = doc.ToArray(); System.IO.File.WriteAllBytes("watermarked.pdf", saved); ``` ## Extract Text Fragments from a Page Use `TextFragmentAbsorber` to enumerate all text fragments on the first page. ```csharp using Aspose.Pdf; using Aspose.Pdf.Text; var data = System.IO.File.ReadAllBytes("document.pdf"); using var doc = Document.Open(data); var absorber = new TextFragmentAbsorber(); absorber.Visit(doc.Pages[1]); foreach (var fragment in absorber.TextFragments) { Console.WriteLine(fragment.Text); } ``` --- # Aspose.PDF FOSS for Python URL: https://products.aspose.org/pdf/python/ Open-source Python library for creating, reading, editing, rendering, and validating PDF documents — MIT licensed with no runtime fees. --- Product: Aspose.PDF Platform: python Page Type: index Canonical URL: https://products.aspose.org/pdf/python/ --- Open-source Python library for PDF creation, editing, text extraction, page rendering, encryption, and PDF/A/UA validation. MIT licensed, no runtime fees. # Aspose.PDF FOSS for Python Open-source Python library for creating, reading, editing, rendering, and validating PDF documents — MIT licensed with no runtime fees. Aspose.PDF FOSS for Python is an open-source library for creating, reading, editing, rendering, and validating PDF documents. Built for Python 3.11 and later, it ships type information and integrates into any Python project (see the install section below). The project is currently in alpha, so APIs and feature coverage continue to evolve ahead of the first stable release. The `Document` class is the central entry point, exposing `pages`, `form`, `outlines`, and `tagged_content` for structural editing alongside `encrypt`, `decrypt`, `merge`, `optimize`, and `flatten` operations. Text is added with `Page.add_text()` and extracted or searched with `PdfExtractor` and `TextFragmentAbsorber`, including phrase- and regex-based replacement and redaction. Pages render to PNG or TIFF raster images through `Page.render()` and `Page.save_as_image()`. Interactive AcroForm fields are created and filled through `Form` and `Field`, and documents can be checked or converted toward PDF/A and PDF/UA compliance with `Document.validate_pdfa()`, `Document.convert_to_pdfa()`, and `Document.auto_tag()`. Aspose.PDF FOSS for Python is released under the MIT license with no runtime fees or usage restrictions. The core package depends only on `cryptography` and `asn1crypto`, with optional extras for Pillow-based image support, Brotli-based WOFF2 decoding, and HarfBuzz-based complex text layout. For enterprise features and support, see [Aspose.PDF for Python — Enterprise Product](https://products.aspose.com/pdf/python/). ## Create a PDF and Add Text Build a new PDF document and add positioned text to a page in a few lines. ```python from aspose_pdf import Document with Document() as document: page = document.pages.add() page.add_text( "Hello from Aspose.PDF FOSS!", x=72, y=720, font_size=18, ) document.save("hello.pdf") ``` ## Render a Page to an Image Load an existing PDF and save its first page as a raster image at a configurable DPI. ```python from aspose_pdf import Document with Document() as document: document.load_from("input.pdf") document.pages[0].save_as_image("page-1.png", dpi=144) ``` ## Extract Text from a PDF Bind a document and pull all of its page text out with the extractor facade. ```python from aspose_pdf import PdfExtractor with PdfExtractor() as extractor: extractor.bind_pdf("input.pdf") extractor.extract_text() print(extractor.get_text()) ``` ## Merge PDF Files Concatenate several PDF files into a single output document. ```python from aspose_pdf import PdfFileEditor with PdfFileEditor() as editor: if not editor.concatenate(["part-1.pdf", "part-2.pdf"], "merged.pdf"): raise RuntimeError(editor.last_exception) ``` --- # Aspose.PDF FOSS for TypeScript URL: https://products.aspose.org/pdf/typescript/ Open-source TypeScript library for creating, editing, converting, annotating, and securing PDF documents — MIT licensed, zero dependencies. --- Product: Aspose.PDF Platform: typescript Page Type: index Canonical URL: https://products.aspose.org/pdf/typescript/ --- MIT-licensed TypeScript library for PDF creation, editing, HTML/Markdown/DOCX conversion, annotations, AcroForms, encryption, and redaction. # Aspose.PDF FOSS for TypeScript Open-source TypeScript library for creating, editing, converting, annotating, and securing PDF documents — MIT licensed, zero dependencies. Aspose.PDF FOSS for TypeScript is an open-source library for creating, editing, converting, and securing PDF documents in Node.js (>=22) applications. The `Document` and `Page` classes are the central entry points: `Document.OpenFile()` / `Document.Open()` load existing files or in-memory bytes, `Document.New()` starts a blank document, and `WriteTo()` / `Save()` write the result back out, optionally with xref-stream compression. The project is a zero-dependency package (Node.js is the only runtime requirement) and is under active early-stage development (currently version 0.1.0). Beyond core document and page editing — splitting, merging, extracting, reordering, and appending pages with `Document.Split()`, `Document.Merge()`, `Document.ExtractPages()`, and `Document.Append()` — the library converts pages and whole documents to other formats with `ToHtml()`, `ToMarkdown()`, `ToDocx()`, `ToSvg()`, `ToImage()`, and `ToEpub()`. Annotation support covers highlight, underline, squiggly, strikeout, link, text-note, free-text, and stamp markup through methods like `Page.AddHighlight()` and `Page.AddStamp()`. AcroForm fields (text, checkbox, radio, combo box, list box, and push button) are built with the `Form` class and its typed `Field` subclasses, and documents can be encrypted with AES-128, AES-256, or RC4, digitally signed with `Document.Sign()`, and redacted with `Document.Redact()` / `Page.ApplyRedactions()`. Aspose.PDF FOSS for TypeScript is released under the MIT license with no runtime fees or usage restrictions (see the install section below). For the enterprise product family, see [Aspose.PDF — Enterprise Product Family](https://products.aspose.com/pdf/). ## Convert a PDF to HTML, Markdown, and DOCX Open a PDF and render it out to several downstream formats in one pass. ```typescript import { Document } from '@asposefoss/pdf'; const doc = Document.OpenFile('in.pdf'); const svg = doc.Pages[0].ToSvg(); // standalone string // fs.writeFileSync('page1.svg', svg); const png = doc.Pages[0].ToImage({ scale: 2 }); // Uint8Array of PNG bytes @144 DPI // fs.writeFileSync('page1.png', png); const html = doc.ToHtml(); // standalone semantic HTML, all pages // fs.writeFileSync('out.html', html); const md = doc.ToMarkdown(); // GFM Markdown, all pages // fs.writeFileSync('out.md', md); const docx = doc.ToDocx(); // .docx bytes, reflowed, images in the package // fs.writeFileSync('out.docx', docx); const fixed = doc.ToDocx({ mode: 'textbox' }); // .docx keeping each page's own geometry // fs.writeFileSync('fixed.docx', fixed); ``` ## Edit Pages and Metadata, Then Save Load a PDF, edit its pages and metadata, and write it back out with compression. ```typescript import { Document } from '@asposefoss/pdf'; // Open from disk (or Document.Open(uint8array) for in-memory data) const doc = Document.OpenFile('input.pdf'); // Inspect and edit pages console.log(doc.Pages.length); doc.Pages[0].Rotate = 90; doc.RemovePage(2); // 1-based page number doc.Reorder([3, 1, 2]); // Metadata doc.SetMetadata({ title: 'Report', author: 'Jane', custom: { Dept: 'R&D' } }); // Save doc.WriteTo('output.pdf'); // or: const bytes = doc.Save(); doc.WriteTo('small.pdf', { compressed: true }); // xref stream + object streams ``` ## Create a New PDF from Scratch Start a blank document, add positioned text, and append another page. ```typescript import { Document, PageFormat } from '@asposefoss/pdf'; const doc = Document.New(PageFormat.A4); // one blank A4 page doc.Pages[0].AddText('Hello', 72, 720, { fontSize: 14 }); doc.AddPage(PageFormat.A4.landscape()); // append more as you go doc.WriteTo('scratch.pdf'); ``` ## Password-Protect and Encrypt a PDF Encrypt an existing PDF with a user/owner password pair and AES-256, restricting copying and modification. ```typescript import { Document } from '@asposefoss/pdf'; const doc = Document.OpenFile('in.pdf'); doc.WriteTo('locked.pdf', { encrypt: { userPassword: 'open-me', // required to open (default '') ownerPassword: 'full-rights', // default: same as userPassword algorithm: 'aes256', // 'aes256' (default) | 'aes128' | 'rc4' permissions: { copying: false, modifying: false }, encryptMetadata: true, }, }); ``` --- # Aspose.PSD FOSS URL: https://products.aspose.org/psd/ Read, edit, and convert Photoshop PSD and PSB files. Open-source, MIT licensed, with no Adobe Photoshop required. --- Product: psd Page Type: index Canonical URL: https://products.aspose.org/psd/ --- Aspose.PSD FOSS is a free, open-source library for reading, editing, and converting Adobe Photoshop PSD and PSB files. MIT licensed. # Aspose.PSD FOSS Read, edit, and convert Photoshop PSD and PSB files. Open-source, MIT licensed, with no Adobe Photoshop required. Aspose.PSD FOSS is coming soon as an open-source library for working with Adobe Photoshop files (PSD and PSB). You will be able to load layered design files, edit visual elements, apply effects, and export images, all without needing Photoshop. The library will support reading and writing PSD/PSB files and will include features like smart object rendering, layer masks, adjustment layers, and text editing. Aspose.PSD FOSS is designed for tasks like generating banners, customizing templates, and automating image editing in both desktop and server apps. Built from a proven core, it will offer reliable performance and flexibility through open-source development. For the enterprise product family, see [Aspose.PSD — Enterprise Product Family](https://products.aspose.com/psd/). --- # Aspose.PUB FOSS URL: https://products.aspose.org/pub/ Read and convert Microsoft Publisher files programmatically. Open-source, MIT licensed, with no Microsoft Publisher required. --- Product: pub Page Type: index Canonical URL: https://products.aspose.org/pub/ --- Aspose.PUB FOSS is a free, open-source library for reading and converting Microsoft Publisher .PUB files to PDF and other formats. MIT licensed. # Aspose.PUB FOSS Read and convert Microsoft Publisher files programmatically. Open-source, MIT licensed, with no Microsoft Publisher required. Aspose.PUB FOSS is coming soon as an open-source library for working with Microsoft Publisher (.pub) files. You will be able to open, read, and inspect .pub files, and convert them to formats like PDF, without needing Microsoft Publisher. This will make it easy to automate document archiving, publishing, and print workflows in both desktop and cloud apps. The library will be simple to integrate for local or server-side processing. For the enterprise product family, see [Aspose.PUB — Enterprise Product Family](https://products.aspose.com/pub/). --- # Aspose.Slides FOSS URL: https://products.aspose.org/slides/ Create, read, and edit PowerPoint presentations — free and open-source, available for .NET, C++, Java, and Python. --- Product: Aspose.Slides Page Type: index Canonical URL: https://products.aspose.org/slides/ --- Aspose.Slides FOSS is a free, open-source library for creating, reading, and editing PowerPoint .pptx presentations. MIT licensed. Available for .NET, C++, Java, and Python. # Aspose.Slides FOSS Create, read, and edit PowerPoint presentations — free and open-source, available for .NET, C++, Java, and Python. Aspose.Slides FOSS is a suite of free, MIT-licensed open-source libraries for creating, reading, and editing PowerPoint presentations, with no Microsoft Office dependency and no native extensions. Each edition works with PPTX files and supports adding slides, inserting shapes, tables, and connectors, formatting text at character level, applying visual effects (shadow, glow, blur, reflection), and round-tripping files safely without losing unknown XML content. Every library in the suite installs with a single package manager command and runs identically on Windows, macOS, Linux, Docker, and serverless. For the enterprise product family, see [Aspose.Slides — Enterprise Product Family](https://products.aspose.com/slides/). ## Related Topics - [Aspose.Slides FOSS for C++](https://products.aspose.org/slides/cpp/) - [Aspose.Slides FOSS for Java](https://products.aspose.org/slides/java/) - [Aspose.Slides FOSS for .NET](https://products.aspose.org/slides/net/) - [Aspose.Slides FOSS for Python](https://products.aspose.org/slides/python/) --- # Aspose.Slides FOSS for C++ URL: https://products.aspose.org/slides/cpp/ Create, read, and edit PowerPoint presentations from C++ — free and open-source, no Office dependency required. --- Product: Aspose.Slides Platform: cpp Page Type: index Canonical URL: https://products.aspose.org/slides/cpp/ --- Aspose.Slides FOSS for C++ is a free, MIT-licensed library for creating, reading, and editing PowerPoint .pptx presentations. No Microsoft Office required. Integrate via CMake FetchContent. Requires a C++20 compiler. # Aspose.Slides FOSS for C++ Create, read, and edit PowerPoint presentations from C++ — free and open-source, no Office dependency required. Aspose.Slides FOSS for C++ is a MIT-licensed library for working with PowerPoint `.pptx` files. Integrate it via CMake FetchContent and immediately start creating, reading, and editing presentations without installing Microsoft Office or any proprietary runtime. The library exposes a Presentation API built around `Presentation`, `Slide`, `ShapeCollection`, `TextFrame`, `Paragraph`, and `Portion`, the conceptual model used by PowerPoint itself. Add and remove slides, insert AutoShapes, Tables, and Connectors, format text at character level with bold, italic, font size and color, apply solid or gradient fills, and add visual effects (shadow, glow, blur, reflection). RAII semantics ensure reliable resource cleanup: the `Presentation` destructor releases all internal state automatically. Unknown XML parts encountered during load are preserved verbatim on save, so round-tripping never destroys content the library does not yet understand. The library requires a C++20-compliant compiler. Developers requiring enterprise features and production support can use [Aspose.Slides for C++ — Enterprise Product](https://products.aspose.com/slides/cpp/) alongside these open-source libraries. ## Create a Presentation and Add a Shape RAII ensures the `Presentation` destructor releases all resources automatically when the object goes out of scope. `add_auto_shape()` takes a `ShapeType` enum, then x/y position and width/height in points — the shape's `text_frame` provides access to set text content. ```cmake include(FetchContent) FetchContent_Declare( aspose_slides_foss GIT_REPOSITORY https://github.com/aspose-slides-foss/Aspose.Slides-FOSS-for-Cpp.git GIT_TAG main ) FetchContent_MakeAvailable(aspose_slides_foss) ``` ```cpp #include #include #include #include #include #include #include #include int main() { Aspose::Slides::Foss::Presentation prs; auto& slide = prs.slides()[0]; // Add a rectangle AutoShape auto& shape = slide.shapes().add_auto_shape( Aspose::Slides::Foss::ShapeType::RECTANGLE, 50, 50, 400, 150 ); shape.text_frame()->set_text("Hello, Aspose.Slides!"); prs.save("output.pptx", Aspose::Slides::Foss::SaveFormat::PPTX); return 0; } ``` ## Format Text and Apply a Fill Effect Text formatting works at the `Portion` level — the smallest unit of a run of characters. Open the saved file, navigate to the first portion of the first paragraph, and set font properties directly. Shape fill is independent: set the fill type to solid and assign a color. ```cpp #include namespace asf = Aspose::Slides::Foss; int main() { asf::Presentation prs("output.pptx"); auto& shape = prs.slides()[0].shapes()[0]; auto& portion = shape.text_frame() ->paragraphs()[0].portions()[0]; // Bold, 18pt text portion.portion_format().set_font_bold(asf::NullableBool::TRUE); portion.portion_format().set_font_height(18); // Solid background fill on the shape shape.fill_format().set_fill_type(asf::FillType::SOLID); prs.save("formatted.pptx", asf::SaveFormat::PPTX); return 0; } ``` --- # Aspose.Slides FOSS for Java URL: https://products.aspose.org/slides/java/ Create, read, and edit PowerPoint presentations from Java — free and open-source, no Office dependency required. --- Product: Aspose.Slides Platform: java Page Type: index Canonical URL: https://products.aspose.org/slides/java/ --- Aspose.Slides FOSS for Java is a free, MIT-licensed pure-Java library for generating and editing PowerPoint .pptx presentations in JVM-based applications. No Microsoft Office required. Add a single Maven dependency to get started. Requires JDK 21+. # Aspose.Slides FOSS for Java Create, read, and edit PowerPoint presentations from Java — free and open-source, no Office dependency required. Aspose.Slides FOSS for Java is a MIT-licensed pure-Java library for working with PowerPoint `.pptx` files. Add a single Maven dependency and immediately start creating, reading, and editing presentations without installing Microsoft Office or any proprietary runtime. The library exposes a Presentation API built around `Presentation`, `Slide`, `Shape`, `TextFrame`, `Paragraph`, and `Portion`, the conceptual model used by PowerPoint itself. Add and remove slides, insert AutoShapes, Tables, and Connectors, format text at character level with bold, italic, font size and color, apply solid or gradient fills, and add visual effects (shadow, glow, blur, reflection). The `Presentation` class implements `AutoCloseable`, so use try-with-resources for reliable cleanup. Unknown XML parts encountered during load are preserved verbatim on save, so round-tripping never destroys content the library does not yet understand. For enterprise features and support, see [Aspose.Slides for Java — Enterprise Product](https://products.aspose.com/slides/java/). ## Create a Presentation and Add a Shape Use try-with-resources to ensure the `Presentation` is always closed and resources are freed. `addAutoShape()` takes a `ShapeType` enum, then x/y position and width/height in points. Call `addTextFrame()` to create the text frame and set the initial text in one call — do not call `getTextFrame()` before `addTextFrame()` as the frame is null until created. ```java import org.aspose.slides.foss.*; try (Presentation prs = new Presentation()) { ISlide slide = prs.getSlides().get(0); // Add a rectangle AutoShape IAutoShape shape = slide.getShapes().addAutoShape( ShapeType.RECTANGLE, 50, 50, 400, 150 ); shape.addTextFrame("Hello, Aspose.Slides!"); prs.save("output.pptx"); } ``` ## Format Text and Apply a Fill Effect Text formatting works at the `Portion` level — the smallest unit of a run of characters. Open the saved file, navigate to the first portion of the first paragraph, and set font properties via getters and setters. Shape fill is independent: set `FillType` to `SOLID` and assign a color via `getSolidFillColor().setColor()`. ```java import org.aspose.slides.foss.*; import org.aspose.slides.foss.drawing.Color; try (Presentation prs = new Presentation("output.pptx")) { IAutoShape shape = (IAutoShape) prs.getSlides().get(0).getShapes().get(0); IPortion portion = shape.getTextFrame() .getParagraphs().get(0).getPortions().get(0); // Bold, 18pt, dark-blue text portion.getPortionFormat().setFontBold(NullableBool.TRUE); portion.getPortionFormat().setFontHeight(18); portion.getPortionFormat().getFillFormat() .getSolidFillColor().setColor(new Color(0, 0, 139)); // Solid background fill on the shape shape.getFillFormat().setFillType(FillType.SOLID); shape.getFillFormat().getSolidFillColor() .setColor(new Color(240, 248, 255)); prs.save("formatted.pptx"); } ``` --- # Aspose.Slides FOSS for .NET URL: https://products.aspose.org/slides/net/ Create, read, and edit PowerPoint presentations from .NET — free and open-source, no Office dependency required. --- Product: Aspose.Slides Platform: net Page Type: index Canonical URL: https://products.aspose.org/slides/net/ --- Aspose.Slides FOSS for .NET is a free, MIT-licensed pure-C# library for reading, creating, and editing PowerPoint .pptx presentations in .NET web and desktop applications. No Microsoft Office required. Requires .NET 9.0+. # Aspose.Slides FOSS for .NET Create, read, and edit PowerPoint presentations from .NET — free and open-source, no Office dependency required. Aspose.Slides FOSS for .NET is a MIT-licensed pure-C# library for working with PowerPoint `.pptx` files. Build it from source and immediately start creating, reading, and editing presentations without installing Microsoft Office or any proprietary runtime. The library exposes a Presentation API built around `Presentation`, `Slide`, `Shape`, `TextFrame`, `Paragraph`, and `Portion`, the conceptual model used by PowerPoint itself. Add and remove slides, insert AutoShapes, Tables, and Connectors, format text at character level with bold, italic, font size and color, apply solid or gradient fills, and add visual effects (shadow, glow, blur, reflection). The `IDisposable` pattern ensures reliable resource cleanup: always wrap a `Presentation` in a `using` statement. Unknown XML parts encountered during load are preserved verbatim on save, so round-tripping never destroys content the library does not yet understand. The library requires .NET 9.0 or later and has no native extensions to compile. Developers requiring enterprise features and production support can use [Aspose.Slides for .NET — Enterprise Product](https://products.aspose.com/slides/net/) alongside these open-source libraries. ## Create a Presentation and Add a Shape Use a `using` statement to ensure the `Presentation` is always disposed and resources are freed. `AddAutoShape()` takes a `ShapeType` enum, then x/y position and width/height in points. Call `AddTextFrame()` to create the text frame and set the initial text in one call — do not access `TextFrame` before calling `AddTextFrame()` as the frame is null until created. ```shell git clone https://github.com/aspose-slides-foss/Aspose.Slides-FOSS-for-.NET.git cd Aspose.Slides-FOSS-for-.NET dotnet build Aspose.Slides.Foss.sln -c Release ``` ```csharp using Aspose.Slides.Foss; using var prs = new Presentation(); var slide = prs.Slides[0]; // Add a rectangle AutoShape var shape = slide.Shapes.AddAutoShape( ShapeType.Rectangle, 50, 50, 400, 150 ); shape.AddTextFrame("Hello, Aspose.Slides!"); prs.Save("output.pptx", SaveFormat.Pptx); ``` ## Format Text and Apply a Fill Effect Text formatting works at the `Portion` level — the smallest unit of a run of characters. Open the saved file, navigate to the first portion of the first paragraph, and set font properties directly. Shape fill is independent: set `FillType` to `Solid` and assign a color to `SolidFillColor.Color`. ```csharp using Aspose.Slides.Foss; using Aspose.Slides.Foss.Drawing; using var prs = new Presentation("output.pptx"); var shape = (IAutoShape)prs.Slides[0].Shapes[0]; var portion = shape.TextFrame.Paragraphs[0].Portions[0]; // Bold, 18pt, dark-blue text portion.PortionFormat.FontBold = NullableBool.True; portion.PortionFormat.FontHeight = 18; portion.PortionFormat.FillFormat.SolidFillColor.Color = Color.FromArgb(255, 0, 0, 139); // Solid background fill on the shape shape.FillFormat.FillType = FillType.Solid; shape.FillFormat.SolidFillColor.Color = Color.FromArgb(255, 240, 248, 255); prs.Save("formatted.pptx", SaveFormat.Pptx); ``` --- # Aspose.Slides FOSS for Python URL: https://products.aspose.org/slides/python/ Create, read, and edit PowerPoint presentations from Python — free and open-source, no Office dependency required. --- Product: Aspose.Slides Platform: python Page Type: index Canonical URL: https://products.aspose.org/slides/python/ --- Aspose.Slides FOSS for Python is a free, MIT-licensed pure-Python library for creating and editing PowerPoint .pptx files in Python scripts and automation workflows. No Microsoft Office required. Install with pip. Requires Python 3.10+. # Aspose.Slides FOSS for Python Create, read, and edit PowerPoint presentations from Python — free and open-source, no Office dependency required. Aspose.Slides FOSS for Python is a MIT-licensed pure-Python library for working with PowerPoint `.pptx` files. Install it with a single pip command and immediately start creating, reading, and editing presentations without installing Microsoft Office or any proprietary runtime. The library exposes a Presentation API built around `Presentation`, `Slide`, `Shape`, `TextFrame`, `Paragraph`, and `Portion`, the conceptual model used by PowerPoint itself. Add and remove slides, insert AutoShapes, Tables, and Connectors, format text at character level with bold, italic, font size and color, apply solid or gradient fills, and add visual effects (shadow, glow, blur, reflection). The context manager pattern ensures reliable resource cleanup: always open a `Presentation` with `with slides.Presentation(...) as prs:`. Unknown XML parts encountered during load are preserved verbatim on save, so round‑tripping never destroys content the library does not yet understand. The library requires Python 3.10 or later and depends only on `lxml`, installed automatically. Developers requiring enterprise features and production support can use [Aspose.Slides for Python — Enterprise Product](https://products.aspose.com/slides/python-net/) alongside these open-source libraries. ## Create a Presentation and Add a Shape Use the context manager (`with slides.Presentation() as prs:`) to ensure the PPTX is always closed and resources are freed. `add_auto_shape()` takes a `ShapeType` enum, then x/y position and width/height in points — call `add_text_frame()` on the shape to attach a text frame and set the label in one line. ```python import aspose.slides_foss as slides from aspose.slides_foss.export import SaveFormat with slides.Presentation() as prs: slide = prs.slides[0] # Add a rectangle AutoShape shape = slide.shapes.add_auto_shape( slides.ShapeType.RECTANGLE, 50, 50, 400, 150 ) shape.add_text_frame("Hello, Aspose.Slides!") prs.save("output.pptx", SaveFormat.PPTX) ``` ## Format Text and Apply a Fill Effect Text formatting works at the `Portion` level — the smallest unit of a run of characters. Open the saved file, navigate to the first portion of the first paragraph, and set font properties directly. Shape fill is independent: set `fill_type` to `SOLID` and assign a color to `solid_fill_color.color`. ```python import aspose.slides_foss as slides from aspose.slides_foss import NullableBool, FillType from aspose.slides_foss.drawing import Color from aspose.slides_foss.export import SaveFormat with slides.Presentation("output.pptx") as prs: shape = prs.slides[0].shapes[0] portion = shape.text_frame.paragraphs[0].portions[0] # Bold, 18pt, dark-blue text portion.portion_format.font_bold = NullableBool.TRUE portion.portion_format.font_height = 18 portion.portion_format.fill_format.fill_type = FillType.SOLID portion.portion_format.fill_format.solid_fill_color.color = Color.dark_blue # Solid background fill on the shape shape.fill_format.fill_type = FillType.SOLID shape.fill_format.solid_fill_color.color = Color.alice_blue prs.save("formatted.pptx", SaveFormat.PPTX) ``` --- # Aspose.SVG FOSS URL: https://products.aspose.org/svg/ Edit, render, and convert SVG files. Open-source, MIT licensed, with no browser engine required. --- Product: svg Page Type: index Canonical URL: https://products.aspose.org/svg/ --- Aspose.SVG FOSS is a free, open-source library for editing, rendering, and converting SVG files to PDF, PNG, JPEG, and more. MIT licensed. # Aspose.SVG FOSS Edit, render, and convert SVG files. Open-source, MIT licensed, with no browser engine required. Aspose.SVG FOSS is coming soon as an open-source library for working with SVG files. You will be able to load, edit, and convert SVG files without needing browser engines or extra tools. The library will let you convert SVG to formats like PDF, PNG, JPEG, and BMP for printing or sharing. You can also programmatically change SVG content, such as editing elements, attributes, styles, and scripts. Aspose.SVG FOSS is fully offline and easy to add to any local or cloud-based app for fast and reliable SVG processing. For the enterprise product family, see [Aspose.SVG — Enterprise Product Family](https://products.aspose.com/svg/). --- # Aspose.Tasks FOSS URL: https://products.aspose.org/tasks/ Read, write, and analyze Microsoft Project files. Open-source, MIT licensed, with no Microsoft Project installation required. --- Product: tasks Page Type: index Canonical URL: https://products.aspose.org/tasks/ --- Aspose.Tasks FOSS is a free, open-source library for reading, writing, and managing Microsoft Project MPP and XML files. MIT licensed. # Aspose.Tasks FOSS Read, write, and analyze Microsoft Project files. Open-source, MIT licensed, with no Microsoft Project installation required. Aspose.Tasks FOSS is coming soon as an open-source library for creating, analyzing, and managing Microsoft Project files like .MPP and .XML, without needing Microsoft Project. The library gives you full access to project details such as tasks, resources, assignments, calendars, constraints, and dependencies. It is ideal for adding planning, scheduling, or reporting features to your applications. You can create project plans, update timelines, calculate critical paths, and export data to PDF or Excel formats. Aspose.Tasks FOSS supports Microsoft Project versions from 2003 to the latest, offering strong compatibility and accuracy. For the enterprise product family, see [Aspose.Tasks — Enterprise Product Family](https://products.aspose.com/tasks/). --- # Aspose.TeX FOSS URL: https://products.aspose.org/tex/ Compile and convert TeX and LaTeX documents. Open-source, MIT licensed, with no external TeX engine required. --- Product: Aspose.TeX Page Type: index Canonical URL: https://products.aspose.org/tex/ --- Aspose.TeX FOSS is a free, open-source library for compiling and converting TeX and LaTeX documents to PDF, XPS, and image formats. MIT licensed. # Aspose.TeX FOSS Compile and convert TeX and LaTeX documents. Open-source, MIT licensed, with no external TeX engine required. Aspose.TeX FOSS is a free, MIT-licensed TeX typesetting engine. It processes TeX markup from strings or files and produces PDF, DVI, or SVG output — no LaTeX installation or external runtime required. The library exposes output devices (PdfDevice, DviDevice, SvgDevice) and a unified TeXJob entry point. Developers use FileInputSource or StringInputSource to supply TeX input and call run() to typeset and obtain output bytes. Aspose.TeX FOSS is suitable for document pipelines, math rendering, and academic publishing applications. For the enterprise product family, see [Aspose.TeX — Enterprise Product Family](https://products.aspose.com/tex/). ## Related Topics - [Aspose.TeX FOSS for Python](https://products.aspose.org/tex/python/) --- # Aspose.TeX FOSS for Python URL: https://products.aspose.org/tex/python/ Free, MIT-licensed Python library to produce PDF, DVI, and SVG output from TeX markup. No LaTeX runtime required. --- Product: Aspose.TeX Platform: python Page Type: index Canonical URL: https://products.aspose.org/tex/python/ --- Aspose.TeX FOSS for Python is a free, MIT-licensed TeX engine that produces PDF, DVI, and SVG output from TeX input. Install with pip. No external runtime required. # Aspose.TeX FOSS for Python Free, MIT-licensed Python library to produce PDF, DVI, and SVG output from TeX markup. No LaTeX runtime required. Aspose.TeX FOSS for Python (aspose-tex) is a free, MIT-licensed TeX typesetting engine for Python developers. It generates PDF, DVI, or SVG output — no LaTeX installation or external runtime required. The library exposes three output devices: `PdfDevice` for PDF output, `DviDevice` for DVI output, and `SvgDevice` for multi-page SVG output. The `TeXJob` class is the main entry point; it accepts a `FileInputSource` or `StringInputSource` and an output device, then runs the typesetting engine when `.run()` is called. Aspose.TeX FOSS for Python is released under the MIT license. It runs in Python 3.10+ environments on all major operating systems including Linux, macOS, and Windows. No Ghostscript or TeX Live dependency required. For the enterprise product, see [Aspose.TeX for Python — Enterprise Product](https://products.aspose.com/tex/python-net/). ## Process TeX to PDF Install the package (see above), then typeset a TeX string to obtain PDF bytes: ```python from aspose_tex import StringInputSource, PdfDevice, TeXJob, TeXOptions opts = TeXOptions(load_format=False) result = TeXJob( StringInputSource(r"Hello -- done"), PdfDevice(), options=opts, ).run() # result is bytes containing a valid PDF ``` ## Process TeX File to SVG Read TeX source from a file and export each page as SVG: ```python from aspose_tex import FileInputSource, SvgDevice, TeXJob, TeXOptions opts = TeXOptions(load_format=False) device = SvgDevice() TeXJob(FileInputSource("input.tex"), device, options=opts).run() pages = device.get_all_pages() # list[bytes] of SVG per page ``` ## Export TeX to DVI Use `DviDevice` to produce DVI output: ```python from aspose_tex import StringInputSource, DviDevice, TeXJob, TeXOptions opts = TeXOptions(load_format=False) result = TeXJob( StringInputSource(r"\hbox{Test}-- done"), DviDevice(), options=opts, ).run() # result is bytes containing DVI data ``` --- # Aspose.Words FOSS URL: https://products.aspose.org/words/ Work with Word documents programmatically — free and open-source, no Microsoft Word required. Available for .NET and Python. --- Product: Aspose.Words Page Type: index Canonical URL: https://products.aspose.org/words/ --- Aspose.Words FOSS is a free, MIT-licensed open-source library for working with Word documents, built from the genuine Aspose.Words codebase. No Microsoft Word required. Available for .NET and Python. # Aspose.Words FOSS Work with Word documents programmatically — free and open-source, no Microsoft Word required. Available for .NET and Python. Aspose.Words FOSS is a suite of free, MIT-licensed open-source libraries built from the genuine Aspose.Words codebase — the same document engine that has processed Word documents in production since 2003. Every edition in the suite works with DOCX files and converts between DOCX, Markdown, and plain text, with no Microsoft Word or Office installation required. Individual editions vary in scope, from document format conversion to full programmatic document creation and editing. See each platform's page below for its specific capabilities and supported formats. For the enterprise product family, see [Aspose.Words — Enterprise Product Family](https://products.aspose.com/words/). ## Related Topics - [Aspose.Words FOSS for .NET](https://products.aspose.org/words/net/) - [Aspose.Words FOSS for Python](https://products.aspose.org/words/python/) --- # Aspose.Words FOSS for .NET URL: https://products.aspose.org/words/net/ Create, read, and edit Word documents from .NET — free and open-source, built from the genuine Aspose.Words engine, no Microsoft Word required. --- Product: Aspose.Words Platform: net Page Type: index Canonical URL: https://products.aspose.org/words/net/ --- Aspose.Words FOSS for .NET is a free, MIT-licensed pure-C# library for creating, reading, and editing DOCX documents. Built from the genuine Aspose.Words engine. No Microsoft Word required. # Aspose.Words FOSS for .NET Create, read, and edit Word documents from .NET — free and open-source, built from the genuine Aspose.Words engine, no Microsoft Word required. Aspose.Words FOSS for .NET is a MIT-licensed pure-C# library for working with Word `.docx` files. It is not a rewrite or a wrapper: it is the actual Aspose.Words for .NET source code, the same document engine that has processed Word documents in production since 2003, reduced down to a free, open-source core. The library exposes the same Document Object Model used by the commercial product — `Document`, `DocumentBuilder`, `Section`, `Paragraph`, `Run`, `Table`, and hundreds of related classes. Create documents from scratch or open existing ones, manipulate text, tables, lists, styles, headers and footers, bookmarks, comments, and footnotes, and convert between DOCX, Markdown, and plain text. A full field evaluation engine is included, so fields such as `DATE`, `DOCPROPERTY`, and mail-merge fields update programmatically (fields that depend on page layout, such as page numbers, evaluate to placeholder values since page layout itself is not part of this edition). The library targets .NET Standard 2.0, so it runs on .NET Framework 4.6.2+, .NET 6/8/10, on Windows, Linux, and macOS, with no native dependencies. Install it via NuGet or build the library from source (see below). Developers requiring enterprise features and production support can use [Aspose.Words for .NET — Enterprise Product](https://products.aspose.com/words/net/) alongside these open-source libraries. ## Create a Document with a Chart Use `DocumentBuilder.InsertChart()` to add a chart shape to a document, then access its `Chart` object to configure series data. Clear the default generated series before adding real data. ```bash git clone https://github.com/aspose-words-foss/Aspose.Words-FOSS-for-.NET.git cd Aspose.Words-FOSS-for-.NET dotnet build Aspose.Words.sln -c Release ``` ```csharp using Aspose.Words; using Aspose.Words.Drawing.Charts; Document doc = new Document(); DocumentBuilder builder = new DocumentBuilder(doc); Shape shape = builder.InsertChart(ChartType.Line, 432, 252); Chart chart = shape.Chart; // Delete default generated series. chart.Series.Clear(); string[] categories = new string[] { "AW Category 1", "AW Category 2", "AW Category 3" }; chart.Series.Add("AW Series 1", categories, new double[] { 4.3, 2.5, 3.5 }); doc.Save("chart.docx"); ``` --- # Aspose.Words FOSS for Python URL: https://products.aspose.org/words/python/ Export Word documents to PDF, Markdown, and plain text from Python — no Microsoft Office required. --- Product: Aspose.Words Platform: python Page Type: index Canonical URL: https://products.aspose.org/words/python/ --- Aspose.Words FOSS for Python is a free, MIT-licensed Python library for reading DOCX, DOC, RTF, and TXT files and exporting to PDF, Markdown, and plain text. Install with pip. Requires Python 3.10+. # Aspose.Words FOSS for Python Export Word documents to PDF, Markdown, and plain text from Python — no Microsoft Office required. Aspose.Words FOSS for Python is a MIT-licensed Python library for loading Word documents and exporting them. It reads DOCX, DOC, RTF, TXT, and Markdown files and exports them to PDF, Markdown, and plain text without requiring Microsoft Office or any proprietary runtime. The library provides a `Document` class for loading files, along with dedicated `LdmMarkdownWriter` and `LdmPdfWriter` classes that write a loaded document to Markdown or PDF and accept save-options objects like `PdfSaveOptions` and `MarkdownSaveOptions`. Note: most save-options properties are defined for API forward-compatibility and are not yet consumed by the writers; only `MarkdownSaveOptions.export_underline_formatting` currently affects output. Install with a single `pip install` command. The library requires Python 3.10 or later and depends on `olefile`, `fpdf2`, and `pydantic`. For enterprise features and support, see [Aspose.Words for Python — Enterprise Product](https://products.aspose.com/words/python-net/). ## Convert DOCX to Markdown Load a Word document and save it as Markdown. ```python import aspose.words_foss as aw from aspose.words_foss.md_writer import LdmMarkdownWriter document = aw.Document("input.docx") # or .doc, .rtf, .txt, .md LdmMarkdownWriter().write(document, "output.md") ``` ## Export DOCX to PDF Export a Word document to PDF format. ```python import aspose.words_foss as aw from aspose.words_foss.pdf_writer import LdmPdfWriter document = aw.Document("input.docx") LdmPdfWriter().write(document, "output.pdf") ``` ## Extract Text from a Document Read all text content from a Word document. ```python import aspose.words_foss as aw document = aw.Document("input.docx") text = document.text ``` --- # Aspose.ZIP FOSS URL: https://products.aspose.org/zip/ Create, extract, and manage ZIP archives with AES encryption. Open-source, MIT licensed, and cross-platform. --- Product: zip Page Type: index Canonical URL: https://products.aspose.org/zip/ --- Aspose.ZIP FOSS is a free, open-source library for creating, extracting, and managing ZIP archives with compression and encryption support. MIT licensed. # Aspose.ZIP FOSS Create, extract, and manage ZIP archives with AES encryption. Open-source, MIT licensed, and cross-platform. Aspose.ZIP FOSS is coming soon as an open-source library for working with ZIP files and file compression. You will be able to create, extract, and manage ZIP archives with features like password protection, AES encryption, and adjustable compression levels. The library is designed for local automation and server workflows, with plans to support more formats like 7z and TAR in the future. Aspose.ZIP FOSS will help automate tasks like deployment, backups, secure file bundling, and efficient file sharing, while allowing developers to extend and improve it through community contributions. For the enterprise product family, see [Aspose.ZIP — Enterprise Product Family](https://products.aspose.com/zip/).