• Introduction
  • Quick Start Guide
  • REST API Reference
  • Javascript API Samples
  • Report Gallery
  • License
  • Welcome to the JasperReports IO Demo App

    This is the sample web application that demonstrates the capabilities of the JasperReports IO reporting service.

    The JasperReports IO (JRIO) is an HTTP based service which exposes its report generating functionality through a REST API.

    The reporting service inside JRIO is based on the functionality of the JasperReports Library (JRL). JRIO acts like a REST API wrapper on top of the reporting Java API of the JRL.

    In this demo application, you'll find sample reports and examples showing how to embed the reporting service into your own application.

    The JRIO service can be deployed in various ways, ranging from monolithic web application, with all its specialized sub-services placed together in the same application (good for testing and small scale deployments), to container based deployments in the Cloud, where specialized sub-services run in separate containers and are able to scale independently while working together to deliver a single embeddable reporting service (suited for large scale deployments).

    Quick Start Guide

    For more detailed documentation, see the TIBCO JasperReports IO User Guide.

    You see this demo application because you have already installed and launched one of the JasperReports IO distributions, which provides this demo application as a convenience, to help you getting started with the product.


    There are several types of distributions available for JRIO and you have probably used one of the following:


    You have probably launched the JRIO reporting service using the default configuration it came with in the distribution you have used.
    Below is a list of some of the configuration settings you can change, to improve your experience with the product or to customize it to your needs.

    Web Application Server (JRIO Professional)

    JRIO start command on Linux:

    ./jre/bin/java -Xms256m -Xmx512m -jar ./jetty/start.jar
        jetty.base=./jrio --start
        -Djetty.http.port=8080 -DSTOP.PORT=8989 -DSTOP.KEY=st0p_J3Tty

    JRIO start command on Windows:

    jre\bin\java -Xms256m -Xmx512m -jar jetty\start.jar
        jetty.base=jrio --start
        -Djetty.http.port=8080 -DSTOP.PORT=8989 -DSTOP.KEY=st0p_J3Tty

    JRIO start command on macOS:

    ./jre/Contents/Home/bin/java -Xms256m -Xmx512m -jar ./jetty/start.jar
        jetty.base=./jrio --start
        -Djetty.http.port=8080 -DSTOP.PORT=8989 -DSTOP.KEY=st0p_J3Tty

    Setting cache size to 4000 objects, to match 4Gb of heap memory:

    <local-cache name="virt" configuration="virtPassivation">
        <object size="4000" />

    With JasperReports IO Professional, the JRIO reporting service is delivered by a Java web application deployed in an Eclipse Jetty server instance shipped inside the JRIO distribution package.

    In the JRIO Professional binary archive distributions, there are two scripts placed in the root folder of the archives, which help you start and stop the Eclipse Jetty server and thus the JRIO reporting service deployed inside it.

    The start script contains the command which starts the Eclipse Jetty server and it specifies several startup configuration parameters that can be changed to better suit your particular environment and needs.

    For more details about how to further configure Eclipse Jetty server at startup, please consult the Jetty documentation.


    The report samples presented in this demo application are delivered by the JRIO reporting service using report templates, sample report data and other required resources found in a file based repository which is part of the same JRIO distribution you are currently using.

    The type of repository, its location and other specific repository implementation properties can be specified in a Spring configuration file.

    In the JasperReports IO Professional distribution package, this configuration file is found at:


    Repository location relative to Web application real path:

    <bean class="com.jaspersoft.jrio.common.repository.WebappRelativeRepositoryFactory">
      <property name="jasperReportsContext" ref="baseJasperReportsContext"/>
      <property name="root" value="../../../repository"/>

    Absolute path repository location:

    <bean class="com.jaspersoft.jrio.common.repository.FileSystemRepository">
      <constructor-arg><ref bean="baseJasperReportsContext"/></constructor-arg>

    AWS S3 bucket repository:

    <bean class="com.jaspersoft.jrio.common.repository.s3.S3RepositoryService">
      <property name="jasperReportsContext" ref="baseJasperReportsContext"/>
      <property name="s3Service">
        <bean class="com.jaspersoft.jrio.common.repository.s3.S3ServiceFactory">
          <property name="region" value="us-east-1"/>
          <property name="accessKey" value="put-id-here"/>
          <property name="secretKey" value="put-key-here"/>
      <property name="bucketName" value="jrio-repo-sample"/>
      <property name="pathPrefix" value="jrio-repository/"/>


    Report Execution Contexts

    The JRIO repository is a folder based structure where the report templates and other report related resources are stored and from where they are retrieved when reports are executed by the JRIO reporting service.

    The main entry point into the report execution process is the master report template (source *.jrxml file or compiled *.jasper file), which is specified using its absolute path within the repository folder structure (its extension being optional), and which in turn can reference other resources from the repository during the report execution.

    Since the JRIO reporting service leverages the reporting functionality of the JasperReports Library, you can learn more about how to create report templates and how to deploy them in the repository by following the JasperReports Library documentation.

    For example, a report having its main template file at the following location within the repository:


    has its report execution context configured using the following file:


    Notice that the ChartCustomizersReport.jrxml file and the JR-INF folder have the same parent folder.

    When a report is executed by JRIO, it is executed into a so called report execution context. Each report has such context defined by the classpath it uses when it is run and by the configuration properties which are set in this context and tailor the behavior of the reporting engine.

    The report execution context for a report is configured using a context.xml file placed in a folder called JR-INF, which has the same parent as the report's main template file.

    If multiple report templates are found in the same folder, they share the same context found in the JR-INF subfolder that accompanies them.
    This means that one way to make sure a report template has its own report execution context that it does not share with any other report, is to isolate this report template into its own subfolder, where a JR-INF folder would define a report execution only for this single report present there.

    Report Execution Context Inheritance

    Report execution contexts inherit from one another and this inheritance can be controlled.

    For example, the report execution context defined at:


    inherits from both the:


    context and the:


    context, if the respective JR-INF folders and their context.xml are present (JR-INF folders are optional).

    For example, if we want the report execution context at:


    to inherit from a sibling context at:


    instead of the default parent folder inheritance, we need to add this to the context.xml:


    The path to the parent context needs to specify the absolute repository path of the parent folder containing the target JR-INF context that we want to use as parent context.

    Notice that the path does not contain the JR-INF folder, just the parent folder of that target report execution context.

    Report Execution Context Classpath

    For example, the report having its main template file at:


    uses custom Java code packaged in the JAR file at:


    by referencing it in the context.xml file at:


    as follows:


    As a Java reporting library, JasperReports has various extension points which allow the customization of its functionality using custom code in the form of compiled Java classes.
    These classes are among the various types of resources that a report might need at execution time and they can also be stored in the repository, along with the subreports, style templates, images, fonts and other report resources.

    Since the Java classes containing the custom functionality need to be loaded by the Java Virtual Machine when a particular report is executed, they need to be referenced in a special way by the reports that use them.

    The custom Java classes needed during a certain report execution need to be packaged as JAR files and placed in the repository, preferably under the JR-INF/lib subfolder of the target report execution context.
    The JAR then needs to be referenced from within the target JR-INF/context.xml file using a pair of <entry><path> tags in the <classpath> tag, so that it will be loaded as part of the dynamic Java classpath used by the reporting service when running reports in this report execution context.

    Report Execution Context Configuration Properties

    Example of setting the chart render type configuration property in a JR-INF/context.xml file:


    The JasperReports Library has many configuration settings that allow tailoring its behavior to specific needs.

    Some of these configuration settings can be set at report context execution level using configuration properties specified in the JR-INF/contex.xml file using <property> tags.

    More details about the configuration settings available for use in report executions contexts, please check the JasperReports Configuration Reference.


    The JasperReports Library which provides the reporting functionality behind the JasperReports IO service, allows reports to call Java code through report expressions during the report execution. While this is a powerful feature of the reporting engine, which gives great flexibility to users to further customize their reports and be able to support complex reporting requirements, it can also be a security vulnerability in case the people deploying the report templates in the JRIO repository are not to be trusted.

    For instance, calls for disk access and calls to System.Exit can be hidden in the report classpath. The previous section of this guide explains how report classpath is configured and controlled by the users who have access to repository content.

    Protection Domain

    Security policy file with the default permissions:

    grant codeBase "file:${java.home}/lib/-" {
    grant codeBase "file:${java.home}/lib/ext/-" {
    grant codeBase "file:${user.dir}/jetty/-" {
    grant codeBase "file:${user.dir}/jrio/webapps/-" {
    //permissions for JRIO repository jars
    grant codeBase "file:/__jrio/repository/jars/" {
    //permissions for JR reports
    grant codeBase "file:/__jrio/repository/reports/" {

    An effective measure against such intrusions is to implement a protection domain. The ProtectionDomain class encloses a group of classes whose instances have the same permissions, public keys, and URI. A given class can belong to only one ProtectionDomain. For more information on ProtectionDomain, see the Java documentation.

    JRIO has preconfigured protection domain that by default gives all permissions to:

    At the same time, this preconfigured protection domain does not give any permission to:

    This default configuration offers a reasonable restrictive security environment which can then be customized to the actual security needs of your specific JRIO deployment.

    Security Manager

    Although JRIO is shipped with this preconfigured protection domain as explained above, the security infrastructure is not activated by default. For activating the protection domain support, the Java security manager needs to be specified when launching the Jetty server. This is done by providing two Java configuration properties when starting the Java Virtual Machine from command line:

    The JRIO startup scripts have these configurations present but commented out. Simply uncommenting the respective lines in the scripts would be enough to activate the Java security infrastructure and its preconfigured protection domain on JRIO service startup.

    Customizing Permissions

    When activating the security manager for the Java Virtual Machine using the above mentioned configuration properties, a security policy file is specified (jrio/security.policy). This file stores the permissions for each defined protection domain and it can be altered to better suit the specific security needs of the current JRIO deployment.

    More details about the syntax of this policy file and what permissions are available can be found in the Java Security documentation.

    Server Side Rendering

    In the JRIO distributions where Chrome is not configured to be used by default for server side rendering, the following property needs to be set in the [JRIO_WEB_APP]/WEB-INF/classes/ to make use of Chrome instead of PhantomsJS or SlimerJS:

    In case the service was not able to find Chrome on the local machine in the usual locations, the following property needs to be set in the [JRIO_WEB_APP]/WEB-INF/classes/ file to point to the location of the Chrome browser executable:

    The following property needs to be set in the [JRIO_WEB_APP]/WEB-INF/classes/ file to point to either the PhantomJS or the SlimerJS executable, which is expected to be found on the same machine where the JRIO service runs:


    The reports generated by the JRIO service can sometimes have visualizations and graphics that are produced by Javascript and other Web-based drawing libraries (see Charts Pro and Custom Visualizations). These work out-of-the-box when the reports are displayed in HTML format and are viewed in the Web browser.
    However, when these reports are exported to PDF and other non-HTML document formats, the Web-based visualizations need to be rendered as images on the server side, where their inclusion in the exported documents occurs.

    For rendering Web visualizations as images, the JRIO service needs a headless browser on the server side so that it can basically make snapshots of these visualizations off-screen. This headless browser functionality is offered by several third party products, and JRIO does not ship any of these in its distribution. They have to be installed separately and the JRIO needs to be configured to make use of them.

    JRIO can be configured to work with either Chrome, PhantomJS or SlimerJS for server side rendering of Web visualizations during non-HTML exports of the reports.

    In the JRIO Professional distributions, Chrome takes precedence over PhantomJS and SlimerJS, being configured to be used by default. The JRIO service will try to find a Chrome installation on the machine where it runs and use it automatically. If not found, it will fall back to using PhantomJS or SlimerJS.

    These two products (PhantomJS and SlimerJS) are interchangeable as they expose the same public API and work the same way, as far as JRIO is concerned. This is why the same configuration property can be used for both. But they are now considered deprecated in JRIO and their use is no longer recommended as both products are no longer maintained by their authors.

    REST API Reference

    The JasperReports IO REST API is an Application Programming Interface that follows the guidelines of REpresentational State Transfer design to allow client application to interact with the server through the HTTP protocol.

    For OpenAPI 3.0 (Swagger) style documentation, see the JasperReports IO REST API in the Swagger UI, where you can actually test it against a live instance of the service.

    Javascript API Samples

    Basic Embed

    Initialization of the jrio.js library with simple rendering of an HTML report.

    Try it: Simple report rendering, from a list

    Use a common configuration to load multiple reports.

    Try it: Load multiple reports


    Try it: Next/previous

    Report Parameters

    Pass a simple set of hard-coded parameters to control report output. This can be expanded with custom input controls such as a drop-down.

    Try it: Parameter passing, basic drop-down

    Select a report hyperlink to open a new "drill-down" report with selected parameter.

    Try it: Basic drill-down, open report in a new page


    Click on the bookmarks to navigate to the page and anchor they point to.

    Try it: Bookmarks

    Search the report content for specific words or phrases.

    Try it: Search


    Listen through events for a change in the page totals and report completed status.

    Try it: Page totals, reports status

    UI Controls

    Dynamically control UI elements for table columns.

    Try it: Table column sorting order, table column conditional formatting


    Custom export options with various formats.

    Try it: Export formats

    Report Gallery

    Jaspersoft Studio

    This section presents a series of sample reports that are meant to show some of the basic reporting capabilities of the JasperReports Library, which are available through the REST API exposed by JRIO.

    Data Grouping

    Repository URI : /samples/reports/FirstJasper

    This is a fairly complex report which displays customer orders grouped by country, in a list format that runs on two columns per page, from top to bottom and then from left to right. The report connects to a demo database through a JDBC data adapter and retrieves the orders by executing an SQL query found in the report template. The report also performs various group, column and page level calculations and displays the values formatted using special format patterns.



    The following reports show how the built-in table component can be used and configured to produce interactive output in which table columns can be selected to open up a pop-up menu with options to format, hide, filter or sort the values.

    Repository URI : /samples/reports/TableReport

    The first table report uses a CSV data adapter (CsvDataAdapter.xml) to retrieve person information, including addresses. Data is grouped by city field, which is displayed once in the table group header. Clicking on the city name will open another report containing a map centered on that city coordinates. The table group footer displays the record count for the current city.


    Repository URI : /samples/reports/OrdersTable

    This second table report displays customer orders from a demo database table, which are grouped by city and filtered on a parameter called city using a contains characters criteria. It signals if the shipped freight quantity is either above or below a certain threshold specified by the optional freight parameter using either green or red arrows pointing up or down, respectively.


    Repository URI : /samples/reports/CustomersTable

    The third table report uses an XML data adapter (northwindData.xml) to retrieve the customers data from the northwind.xml file, which will be displayed in a table component.
    Orders for each customer are read from the same data file and get collected in a subreport that uses a table component as well.



    Repository URI : /samples/reports/crosstabs/OrdersReport

    This report connects to a demo database using a JDBC data adapter and retrieves customer orders using an SQL query that is stored in the report template itself.
    It then processes the customer orders and aggregates the information into a crosstab which displays the number of orders and the latest order date grouped by country on rows and by freight range on columns.


    Repository URI : /samples/reports/crosstabs/ShipmentsReport

    This second crosstab report uses the same customer order data, but aggregates orders freight by region and city on rows and by year and month on columns.
    Besides showing multi level grouping on both rows and columns, it also shows how a crosstab breaks and wraps when its width is larger than the page width.


    Charts (Static)

    The following reports connect to a demo database through a JDBC data adapter and retrieve orders data by performing an SQL query, also stored in the report template.
    Then they process the orders and aggregate the information to be displayed into various chart types, rendered with the JFreeChart library. The available data is grouped by both country and by country's name first letter.

    Repository URI : /samples/reports/charts/AreaChartReport
    Repository URI : /samples/reports/charts/BarChartReport
    Repository URI : /samples/reports/charts/Bar3DChartReport
    Repository URI : /samples/reports/charts/BubbleChartReport
    Repository URI : /samples/reports/charts/CandlestickChartReport

    Repository URI : /samples/reports/charts/GanttChartReport
    Repository URI : /samples/reports/charts/HighLowChartReport
    Repository URI : /samples/reports/charts/LineChartReport
    Repository URI : /samples/reports/charts/MeterChartReport

    Repository URI : /samples/reports/charts/MultipleAxisChartReport
    Repository URI : /samples/reports/charts/PieChartReport
    Repository URI : /samples/reports/charts/Pie3DChartReport
    Repository URI : /samples/reports/charts/ScatterChartReport
    Repository URI : /samples/reports/charts/StackedAreaChartReport

    Repository URI : /samples/reports/charts/StackedBarChartReport
    Repository URI : /samples/reports/charts/StackedBar3DChartReport
    Repository URI : /samples/reports/charts/ThermometerChartReport
    Repository URI : /samples/reports/charts/TimeSeriesChartReport
    Repository URI : /samples/reports/charts/XYAreaChartReport

    Repository URI : /samples/reports/charts/XYBarChartReport
    Repository URI : /samples/reports/charts/XYBarChartTimePeriodReport
    Repository URI : /samples/reports/charts/XYBarChartTimeSeriesReport
    Repository URI : /samples/reports/charts/XYLineChartReport

    Chart Types

    Area Try it: VIEWPDFXLSX
    Bar Try it: VIEWPDFXLSX
    Bar 3D Try it: VIEWPDFXLSX
    Bubble Try it: VIEWPDFXLSX
    Candlestick Try it: VIEWPDFXLSX
    Gantt Try it: VIEWPDFXLSX
    High Low Try it: VIEWPDFXLSX
    Line Try it: VIEWPDFXLSX
    Meter Try it: VIEWPDFXLSX
    Multiple Axis Try it: VIEWPDFXLSX
    Pie Try it: VIEWPDFXLSX
    Pie 3D Try it: VIEWPDFXLSX
    Scatter Try it: VIEWPDFXLSX
    Stacked Area Try it: VIEWPDFXLSX
    Stacked Bar Try it: VIEWPDFXLSX
    Stacked Bar 3D Try it: VIEWPDFXLSX
    Thermometer Try it: VIEWPDFXLSX
    Time Series Try it: VIEWPDFXLSX
    XY Area Try it: VIEWPDFXLSX
    XY Bar Try it: VIEWPDFXLSX
    XY Bar Time Period Try it: VIEWPDFXLSX
    XY Bar Time Series Try it: VIEWPDFXLSX
    XY Line Try it: VIEWPDFXLSX

    Chart Themes

    Repository URI : /samples/reports/chartthemes/ChartThemesReport

    Repository URI : /samples/reports/chartthemes/ChartThemesReport

    This report retrieves sales data from various CSV data files, based on report subdatasets that use CSV data adapters.
    The sales data is then processed and aggregated to be displayed into various chart types, rendered with the JFreeChart library. All charts in the report share the same chart theme who's name can be passed in as chartTheme report parameter.

    Eye Candy Sixties Try it: VIEWPDFXLSX
    Aegean Try it: VIEWPDFXLSX

    Chart Customizers

    Repository URI : /samples/reports/chartcustomizers/ChartCustomizersReport

    This report uses report subdatasets to retrieve sales data from two CSV data files (category.csv and xy.csv) based on built-in CSV data adapters.
    Then the data is processed and aggregated to be displayed into a customized bar chart / XY line chart, based on specific chart customizer classes. The customized bar chart displays star-like legend shapes and a category marker placed on a given category (sally). The customized XY line chart displays step lines with no shapes.


    Charts Pro (Interactive)

    Repository URI : /samples/reports/highcharts/HighchartsChart

    The HighchartsChart report connects to a CSV data file through a CSV data adapter to retrieve customer orders data.
    This data is then processed and aggregated to be displayed into various chart types, rendered with the Highcharts library. The orders are filtered by country name and grouped by regions.
    The report presents two interactive charts: pie and multiaxis. Tooltips appear when mouse comes over a given region in the pie chart or over a given point or bar in the multiaxis chart. One can change the chart type by clicking on the Chart Types... button displayed near each chart. A dialog will open with available chart types and we can then select the desired type. The related chart will change automatically to the new type.



    Repository URI : /samples/reports/ImagesReport

    This report shows how various image types (JPEG, GIF, SVG, PNG, TIFF) can be embedded into a report. Images are collected from different locations, including the local file system and network URLs. The scaleImage attribute is used to adjust/clip the image size within its container. Some of the images provide hyperlinks.



    Repository URI : /samples/reports/Barcode4JReport

    The Barcode4JReport shows how barcode images generated either with the Barcode4J library or with the Google zxing library (for the QRCode component) can be embedded into a report.


    Repository URI : /samples/reports/barbecue/BarbecueReport

    The BarbecueReport shows how barcode images generated with the Barbecue library can be embedded into a report.



    Repository URI : /samples/reports/map/MapReport

    The Google Map report (MapReport) shows how Google maps can be embedded into a report, based on the built-in Google map component. Both markers and paths are supported by this component. The main report connects to an empty data adapter with 5 records, and 5 different map components are loaded as subreports into detail sections. In order to configure maps, markers and paths data are supplied through report subdatasets using CSV data adapters (MapCsvDataAdapter.xml, PathLocationDataAdapter.xml, PathStyleDataAdapter.xml) to connect to data files.



    Repository URI : /samples/reports/unicode/UnicodeReport

    The UnicodeReport shows how Unicode characters can be rendered into a report. It uses either the \uXXXX unicode character notation or the character itself, since the JRXML file encoding is set by default to "UTF-8". In order to properly represent these characters, the report makes use of 3 font libraries added as font extensions: DejaVu, Arphic and Google Noto.


    The internationalized I18nReport illustrates how resource bundle files can be used to render the same report in different languages. In order to do so, it sets the resourceBundle attribute with the appropriate path value for the resource bundle files location: resourceBundle="/samples/reports/i18n/i18n". To render a i18n text, the report uses the $R{} syntax. It can be rendered in the following languages:

    Repository URI : /samples/reports/unicode/i18n/I18nReport

    German Try it: VIEWPDFXLSX
    English Try it: VIEWPDFXLSX
    French Try it: VIEWPDFXLSX
    Portuguese Try it: VIEWPDFXLSX
    Romanian Try it: VIEWPDFXLSX

    Styled Text

    Repository URI : /samples/reports/markup/MarkupReport

    The MarkupReport shows how various types of styled text can be used in report, by setting the markup attribute of the element with one of the following values:


    Repository URI : /samples/reports/HyperlinkReport

    This report shows how hyperlinks of different types, such as:

    can be configured and used within a report.


    Report Books

    The following reports are based on report parts, used instead of bands inside report sections. A report part is somehow similar to a subreport, but pages generated from a part are directly included within the generated report, and not embedded into the pages of the parent report. One of the main advantages of using a report part is that each part may have its own page layout settings, therefore the generated document can consist in sections with different page layout and L&F settings. Also, table of contents sections can be easily generated, based on available local anchor elements and bookmark levels set in the report.

    Repository URI : /samples/reports/book/BookReport

    The BookReport report is made of 3 report parts: Table of Contents, Overview and Shipments. It connects to a demo database through a JDBC data adapter and retrieves data by performing a SQL query stored in the report template. The Overview and Shipments parts use the same connection to retrieve their data.
    The Table of Contents section is generated using the property, which tells about the bookmarks datasource object. In our case the property value is set to "REPORT_DATA_SOURCE", instructing the JR engine that report bookmarks should be used directly to populate the bookmark datasource.
    The Overview part processes the customer orders collected from the demo database and aggregates the information into a crosstab which displays the number of orders and the latest order date grouped by country on rows and by freight range on columns. The page layout orientation for this section is set as Landscape.
    The Shipments part is placed in the detail section of the report, so it will be loaded once per each distinct country in the report datasource. For a given country orders data are grouped by city and represented in the form of both a pie chart and a table. The page layout orientation for this section is set back as Portrait.


    Repository URI : /samples/reports/tableofcontents/TableOfContentsReport

    The TableOfContentsReport is made of 2 report parts: Table of Contents and Countries. It connects to a demo database through a JDBC data adapter to retrieve the total number of orders. The Countries part uses the same connection to retrieve orders. Data is then grouped by the first letter of the country name and further by the county name. It is displayed in a table-like structure.
    To be generated, the Table of Contents section needs a bookmark datasource, characterized by 3 fields:

    When the property is set to "REPORT_DATA_SOURCE", this tells the JR engine that report bookmarks should be used to populate the bookmark datasource.
    One can see in the Table of Contents section country names' starting letter as bookmarks of level 1, and subsequent country names as bookmarks of level 2.


    Custom Visualizations

    Repository URI : /samples/reports/cvc/Figures
    Repository URI : /samples/reports/cvc/LeafletMarkers
    Repository URI : /samples/reports/cvc/RadialProgress
    Repository URI : /samples/reports/cvc/Sparkline

    The Custom Visualization Components are an extension point that the JasperReports Library exposes to allow you to embed third-party Javascript-based visualizations into the reports.
    The following reports show a few basic examples of custom-made visualizations that leverage D3, Leaflet and other Javascript libraries to render interactive and animated graphics.

    Figures Try it: VIEWPDFXLSX
    Leaflef Markers Try it: VIEWPDFXLSX
    Radial Progress Try it: VIEWPDFXLSX
    Sparkline Try it: VIEWPDFXLSX

    Other Reports

    Repo URI PDF Excel
    /samples/reports/fonts/FontsReport PDF XLSX
    /samples/reports/NoPagesReport PDF XLSX
    /samples/reports/SlowReport PDF XLSX
    /samples/reports/GroovyReport PDF XLSX


    End User License Agreement

    For complete license and notices, see the TIBCO JasperReports IO License and Notices.