trino: Open Source Marketing & Customer Engagement

What is trino?

Trino is a distributed SQL query engine for big data analytics, published as the official Apache-2.0-licensed Java repository of the project formerly known as PrestoSQL, and it is aimed at teams that need to query data spread across Hadoop, Hive, Iceberg, Delta Lake and other large-scale sources through a single SQL interface.

What it is

Trino is an open-source, distributed SQL query engine for big data analytics, distributed as the official repository of the project formerly known as PrestoSQL and documented at https://trino.io. The codebase is written in Java and released under the Apache-2.0 licence. The repository carries 13,241 stars and 3,777 forks, and its topic list places it squarely in the analytics, big-data, data-science, database, data-lake, distributed-database and distributed-systems space.

The concrete problem Trino solves is querying big data where it already lives rather than moving it first. Its topic list and documentation connect it to Hadoop, Hive, Iceberg and Delta Lake, so an analyst can point SQL at those systems instead of extracting data into a separate warehouse. In ecosystem terms, Trino is the direct continuation of PrestoSQL under a new name, and the repository is the official home of that continuation.

Key capabilities

Builds as a standard Maven project with ./mvnw clean install -DskipTests, caching dependencies in ~/.m2/repository on the first build.
Ships a development server runnable through the TpchQueryRunner class, which starts a server preconfigured with the TPCH connector; many connectors have their own *QueryRunner class.
Runs the full server from io.trino.server.DevelopmentServer using the sample configuration in etc/config.properties and etc/log.properties.
Supports reproducible builds as of version 449.
Covers Hadoop, Hive, Iceberg and Delta Lake through its connector and topic surface, alongside the analytics and data-science topics.
Requires Java 25.0.1+ (64-bit) and Docker for building, with JDK 25 selected and language level set to 25 in the IDE; IntelliJ IDEA is the recommended environment.
Runs a comprehensive test suite in CI; the local build command deliberately disables those tests because they take considerable time.

Who uses it and how

Analytics and data-science teams query lakehouse formats such as Iceberg and Delta Lake, and Hive and Hadoop warehouses, through one SQL engine.
Self-hosters deploy the server following the deployment instructions in the User Manual, on Mac OS X or Linux.
Plugin developers work against DEVELOPMENT.md, which documents the release process, code style and guidelines for implementors of Trino plugins.
Contributors follow the requirements in CONTRIBUTING.md; the full test suite runs in CI when a pull request is submitted.
Developers building on Apple Silicon need Rosetta 2 installed, because some npm packages used to build the web UI are available only for x86 architectures.

Getting started

Deployment instructions and end-user documentation live in the User Manual at https://trino.io. For a source build, run ./mvnw clean install -DskipTests from the project root, then launch io.trino.server.DevelopmentServer with the sample etc/config.properties and etc/log.properties.

How it compares

No list of paid alternatives is given in the facts, so the relevant comparison is with the tools named alongside it. Trino is the renamed continuation of PrestoSQL and remains the official repository for that lineage, while Hive, Iceberg and Delta Lake appear here as the storage and table-format systems it queries rather than as engines it replaces.

When to use it — and when not to

A self-hoster must operate a Java 25.0.1+ runtime and Docker, adjust SELinux or other systems that block write access to the local checkout so containers can mount the source tree, and accept a build that depends on x86-only npm packages for the web UI. Teams wanting a managed service, or those unwilling to run JDK 25 and Docker for development, should look elsewhere. The repository also carries 2,764 open issues, so expect an active but busy project rather than a small, quiet one.

project readme (upstream, from github) — read inline

Trino is a fast distributed SQL query engine for big data analytics.

See the User Manual for deployment instructions and end user documentation.

Development

See DEVELOPMENT for information about development and release process, code style and guidelines for implementors of Trino plugins.

See CONTRIBUTING for contribution requirements.

Security

See the project security policy for information about reporting vulnerabilities.

Trino supports reproducible builds as of version 449.

Build requirements

Mac OS X or Linux
- Note that some npm packages used to build the web UI are only available for x86 architectures, so if you're building on Apple Silicon, you need to have Rosetta 2 installed.
Java 25.0.1+, 64-bit
Docker
- Turn SELinux or other systems disabling write access to the local checkout off, to allow containers to mount parts of the Trino source tree

Building Trino

Trino is a standard Maven project. Simply run the following command from the project root directory:

./mvnw clean install -DskipTests

On the first build, Maven downloads all the dependencies from the internet and caches them in the local repository (~/.m2/repository), which can take a while, depending on your connection speed. Subsequent builds are faster.

Trino has a comprehensive set of tests that take a considerable amount of time to run, and are thus disabled by the above command. These tests are run by the CI system when you submit a pull request. We recommend only running tests locally for the areas of code that you change.

Running Trino in your IDE

Overview

After building Trino for the first time, you can load the project into your IDE and run the server. We recommend using IntelliJ IDEA. Because Trino is a standard Maven project, you can easily import it into your IDE. In IntelliJ, choose Open Project from the Quick Start box or choose Open from the File menu and select the root pom.xml file.

After opening the project in IntelliJ, double-check that the Java SDK is properly configured for the project:

Open the File menu and select Project Structure
In the SDKs section, ensure that JDK 25 is selected (create one if none exist)
In the Project section, ensure the Project language level is set to 25

Running a testing server

The simplest way to run Trino for development is to run the TpchQueryRunner class. It will start a development version of the server that is configured with the TPCH connector. You can then use the CLI to execute queries against this server. Many other connectors have their own *QueryRunner class that you can use when working on a specific connector. The VM option generally required here is --add-modules jdk.incubator.vector, but various *QueryRunner classes might require additional options (if necessary, check the air.test.jvm.additional-arguments property in the pom.xml file of the module from which the runner comes).

Running tests from the IDE

When running individual test classes directly from IntelliJ, you need to configure the JUnit run configuration template. Go to Run/Debug Configurations > Edit Configuration Templates > JUnit > VM options and set the value to -ea --add-modules=jdk.incubator.vector. Some tests may rely on JVM options provided by airbase (e.g. -XX:-OmitStackTraceInFastThrow), so check for that too.

Running the full server

Trino comes with sample configuration that should work out-of-the-box for development. Use the following options to create a run configuration:

Main Class: io.trino.server.DevelopmentServer
VM Options: -ea -Dconfig=etc/config.properties -Dlog.levels-file=etc/log.properties -Djdk.attach.allowAttachSelf=true --sun-misc-unsafe-memory-access=allow --add-modules jdk.incubator.vector
Working directory: $MODULE_DIR$
Use classpath of module: trino-server-dev

The working directory should be the trino-server-dev subdirectory. In IntelliJ, using $MODULE_DIR$ accomplishes this automatically.

If VM options doesn't exist in the dialog, you need to select Modify options and enable Add VM options.

To adjust which plugins are enabled for the development server, adjust the value of plugin.bundles in config.properties. Each entry in this list must represent a plugin specified by one of the following options:

A path to a pom.xml or *.pom file describing a Maven project that produces a plugin.
Maven coordinates, in the form :[:[:]]:. The plugin will be loaded via Maven and therefore must be available in your local repository or a remote repository.
A path to a plugin directory containing JAR files. See Deploying a custom plugin for more details.

If you want to use a plugin in a catalog, you must add a corresponding .properties file to testing/trino-server-dev/etc/catalog.

Running the CLI

Start the CLI to connect to the server and run SQL queries:

client/trino-cli/target/trino-cli-*-executable.jar

Run a query to see the nodes in the cluster:

SELECT * FROM system.runtime.nodes;

Run a query against the TPCH connector:

SELECT * FROM tpch.tiny.region;

Frequently asked questions

Is trino free to use?

trino is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does trino do?

Official repository of Trino, the distributed SQL query engine for big data, formerly known as PrestoSQL (https://trino.io)

What is trino written in?

trino is primarily written in Java. Its source is publicly available at https://github.com/trinodb/trino, and it has 13,246 GitHub stars.