Table of Contents

List & Label Cross Platform

List & Label Cross Platform (LLCP) is a modern, cross-platform reporting engine for .NET applications.
It enables server-side and cloud-ready report generation on Linux, macOS, and Windows using a unified API and JSON-based project files.

LLCP is designed for automated, scalable report generation and integrates seamlessly into backend services, containers, and CI/CD pipelines.

When to use LLCP

Use LLCP when you need:

  • Server-side or background report generation
  • Deployment on Linux, macOS, Windows, or in containers
  • Integration into cloud or microservice architectures
  • Version-controlled report definitions (JSON-based project files)
  • High-performance export to PDF, images, and other formats

When NOT to use LLCP

LLCP is not the right choice when you need:

  • Interactive report design within your application
    No embedded designer. Templates must be created using the Windows-based List & Label Designer.

  • Interactive preview dialogs
    No preview UI or print dialogs. Headless printing is supported via
    combit.ListLabel31.CrossPlatform.Printing.Pdf.

  • Full Classic Edition feature parity
    Some advanced features and legacy APIs are not available.

  • Desktop-first Windows applications with user interaction
    The Classic Edition is better suited for interactive workflows.

Important

If you're unsure, test a subset of your reports using the migration guide:
Migrating from Classic Edition

Choosing between Classic Edition and Cross Platform

Criterion Classic Edition Cross Platform
Platform Windows only Linux, macOS, Windows
Designer Embedded External (Windows Designer)
Preview & printing Interactive dialogs Headless, server-side
Project format Binary (.lst, .lbl) JSON
Rendering GDI+ SkiaSharp
Cloud readiness Limited Designed for containers
Scalability Vertical Horizontal
Note

Use Classic Edition for interactive desktop scenarios.
Use LLCP for server-side, cloud, and automated workflows.

Core concepts

LLCP is built around a few key design principles:

  • JSON project files
    Human-readable, version-controllable, diff-friendly

  • Skia-based rendering
    Consistent output across all platforms

  • Headless architecture
    No UI dependencies, optimized for automation

  • Stateless execution
    Enables horizontal scaling in containers and cloud environments

Architecture overview

A typical LLCP workflow:

.NET Application
      |
      | (Data binding via IDataProvider)
      |
List & Label Cross Platform API
      |
      | (Loads JSON project definition)
      |
Layout & Rendering Engine (SkiaSharp)
      |
Export Pipeline
      |
Output (PDF, JSON, CSV, PNG, JPEG, SVG, XLSX)

LLCP is independent of platform-specific graphics APIs and produces consistent output across operating systems.

Getting started

1. Install the NuGet package

dotnet add package combit.ListLabel31.CrossPlatform
Tip

A daily-updated prerelease feed is available at https://nuget.combit.net/nuget. It delivers the latest fixes and features ahead of official service pack releases - useful for testing, hotfixes, or early access to new functionality. Packages on this feed have passed the standard test suite, but undocumented APIs may still change before the official release.

To use it, add the URL as a Package Source in your NuGet Package Manager settings, then select that source when adding the package and enable Include Prerelease. The regular packages on nuget.org are not affected and continue to be updated with each official release.

Note

The NuGet package can be installed and evaluated freely for testing and development purposes.
However, an Enterprise Edition license is required to remove the trial watermark from generated output.

2. Create a ListLabel instance and export a report

ListLabel listLabel = new ListLabel
{
    DataSource = GetNorthwindDataSet(),
    AutoProjectFile = projectFilePath,
    LicensingInfo = "..."
};

ExportConfiguration exportConfiguration =
    new ExportConfiguration(LlExportTarget.Pdf, exportFilePath, projectFilePath);

exportConfiguration.ShowResult = true;
listLabel.Export(exportConfiguration);

  • DataSource — provides the report data
    See Providing data

  • AutoProjectFile — the report definition (JSON or repository)

  • LicensingInfo — required license string

  • ExportConfiguration — defines output format and target

For all export formats and requirements, see:
Exporting reports

Performance characteristics

LLCP is optimized for predictable, high-throughput report generation.

The engine automatically handles:

  • Text measurement and layout calculation
  • Caching of layout and rendering results
  • Efficient processing of vector graphics via SkiaSharp

Typical strengths:

  • Batch processing of large report volumes
  • Reuse of report templates
  • Containerized and horizontally scaled environments

Migration notes

When migrating from Classic Edition:

  • Remove or adapt unsupported features
  • Use LL.IsCrossPlatform for conditional logic
  • Validate layout and rendering differences
  • Test all reports after conversion

See: Migrating from Classic Edition

Where to go next

Additional resources