fop-render

Multi-format rendering backends for the COOLJAPAN FOP ecosystem. Transforms the area tree produced by fop-layout into 7 output formats across 6 renderer structs — PDF, SVG, PostScript, plain text, PNG, and JPEG — plus streaming and parallel PDF renderers for large-scale workloads.

Version: 0.1.1 — Released: 2026-04-20

Installation

Add to your Cargo.toml:

[dependencies]
fop-render = "0.1"

To include PNG/JPEG raster output (enabled by default):

[dependencies]
fop-render = { version = "0.1", features = ["raster"] }

To disable raster and keep only vector/text formats:

[dependencies]
fop-render = { version = "0.1", default-features = false }

Supported Output Formats

Usage Examples

PDF Output

use fop_core::FoTreeBuilder;
use fop_layout::LayoutEngine;
use fop_render::PdfRenderer;
use std::io::Cursor;

fn render_pdf() -> Result<(), Box<dyn std::error::Error>> {
    let xml = r#"<?xml version="1.0"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
    <fo:layout-master-set>
        <fo:simple-page-master master-name="A4"
            page-width="210mm" page-height="297mm">
            <fo:region-body margin="1in"/>
        </fo:simple-page-master>
    </fo:layout-master-set>
    <fo:page-sequence master-reference="A4">
        <fo:flow flow-name="xsl-region-body">
            <fo:block font-size="14pt">Hello, PDF!</fo:block>
        </fo:flow>
    </fo:page-sequence>
</fo:root>"#;

    let fo_tree = FoTreeBuilder::new().parse(Cursor::new(xml))?;
    let area_tree = LayoutEngine::new().layout(&fo_tree)?;

    let renderer = PdfRenderer::new();
    let pdf_doc = renderer.render(&area_tree)?;
    let bytes = pdf_doc.to_bytes()?;

    std::fs::write("output.pdf", &bytes)?;
    Ok(())
}

SVG Output

use fop_render::SvgRenderer;

fn render_svg(area_tree: &fop_layout::AreaTree) -> Result<(), Box<dyn std::error::Error>> {
    let renderer = SvgRenderer::new();
    let svg_doc = renderer.render(area_tree)?;
    let svg_string = svg_doc.to_string();

    std::fs::write("output.svg", svg_string)?;
    Ok(())
}

PostScript Output

use fop_render::PsRenderer;

fn render_ps(area_tree: &fop_layout::AreaTree) -> Result<(), Box<dyn std::error::Error>> {
    let renderer = PsRenderer::new();
    let ps_doc = renderer.render(area_tree)?;
    let ps_bytes = ps_doc.to_bytes()?;

    std::fs::write("output.ps", &ps_bytes)?;
    Ok(())
}

Plain Text Output

use fop_render::TextRenderer;

fn render_text(area_tree: &fop_layout::AreaTree) -> Result<(), Box<dyn std::error::Error>> {
    let renderer = TextRenderer::new();
    let text_output = renderer.render(area_tree)?;

    std::fs::write("output.txt", text_output)?;
    Ok(())
}

Streaming PDF (Large Documents)

use fop_render::StreamingPdfRenderer;
use std::fs::File;

fn render_streaming(area_tree: &fop_layout::AreaTree) -> Result<(), Box<dyn std::error::Error>> {
    let file = File::create("large_output.pdf")?;
    let mut renderer = StreamingPdfRenderer::new(file);
    renderer.render(area_tree)?;
    renderer.finish()?;
    Ok(())
}

Raster Output (PNG / JPEG)

Requires the raster feature (enabled by default).

use fop_render::{RasterRenderer, RasterFormat};

fn render_png(area_tree: &fop_layout::AreaTree) -> Result<(), Box<dyn std::error::Error>> {
    let renderer = RasterRenderer::new(RasterFormat::Png);
    let pages = renderer.render(area_tree)?;

    for (i, page_bytes) in pages.iter().enumerate() {
        std::fs::write(format!("page_{}.png", i + 1), page_bytes)?;
    }
    Ok(())
}

Feature Flags

Architecture

Total: 15,357 lines across 24 files

Public API

Renderers

Document Types

PdfDocument, SvgDocument, SvgGraphics, PsDocument, PdfGraphics, RasterFormat

PDF Features

PdfSecurity, PdfPermissions, EncryptionAlgorithm, EncryptionDict, PdfCompliance, PdfValidator, ValidationResult, FontConfig

Image Support

ImageFormat, ImageInfo, ImagePlacement

Generated PDF Structure

%PDF-1.4
1 0 obj  << /Type /Catalog /Pages 2 0 R >>
2 0 obj  << /Type /Pages /Kids [...] /Count N >>
3 0 obj  << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
4 0 obj  << /Type /Page /Parent 2 0 R /Contents 5 0 R >>
5 0 obj  << /Length ... >> stream ... endstream
...
xref
trailer
%%EOF

Tests

23+ unit tests covering:

• PDF document structure (catalog, page tree)
• PDF serialization and cross-reference table
• Text rendering with font selection
• Graphics operations (lines, rectangles, colors)
• Image format detection (PNG, JPEG, GIF, TIFF, SVG, BMP)
• Image dimension extraction from file headers
• Aspect ratio calculation and placement
• SVG, PostScript, plain text output
• Encryption (RC4, AES)
• PDF structural validation

Dependencies

Required

Optional (raster feature)

Related Crates

License

Apache-2.0

Author

COOLJAPAN OU (Team Kitasan)

Copyright 2024-2026 COOLJAPAN OU