Pentaho Kettle builds eight Maven modules and hands you a SNAPSHOT zip
Pentaho Data Integration ( ETL ) a.k.a Kettle
At a glance
- What is it?
- Pentaho Data Integration, or Kettle, is a Java ETL toolkit whose README documents how to compile it rather than how to install a product: Maven, JDK 11, a module map, two test lifecycles and a Jira-first contribution flow. The README's example build output is a SNAPSHOT archive, and the README names no release channel.
- Who is it for?
- Build Pentaho Kettle from source when you need to change core, engine, engine-ext or a core plugin and can accept owning your own build, and use a packaged release instead when you only need to run transformations. Verify two things first: that mvn clean install resolves with the Pentaho settings.xml in place on JDK 11, and what your organisation's policy says about LICENSE.TXT, whose terms the README never states.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Java, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- pentaho/pentaho-kettle8,416 ★ · +17
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| pentaho/pentaho-kettle | 8.4k | 8.4k |
17 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The engine and the UI are separate Maven modules
The structure section of the README is a module map, and each entry says what it carries. core is the core implementation. engine is the PDI engine, and engine-ext holds its extensions, so engine work is split from the work of adding to it. ui is the user interface and dbdialog is the database dialog, which is why a change to how database connections are presented does not have to live next to the transformation engine. integration is for integration tests, plugins holds the core plugins, and assemblies is where the project distribution archive is produced.
Two things about that map are worth a second look. The engine and the interface are separate artifacts, so a headless runner can be wired against engine without the ui module, and a bug in a connection dialog does not need an engine release. The other is that the repository root holds a utilities/ directory the structure section never describes, which tells you the map is a summary of the parts you build, not an inventory of the tree.
JDK 11, Maven 3 and a settings.xml you fetch yourself
Three prerequisites stand between you and a build, and one of them lives outside the repository. Maven must be version 3 or newer, the JDK must be 11, and a Pentaho settings.xml has to sit in your user home .m2 directory. That file is fetched from the pentaho/maven-parent-poms repository, not read from this project.
That third item is the one that costs an afternoon. A contributor who clones the tree, installs a JDK and runs Maven without that file gets dependency resolution failures against repositories the project expects to exist, and nothing in this repository explains where those artifacts live. Two further details: there is no Maven wrapper in the root, so the mvn on your path is the Maven that runs, and the README names one JDK version, which means the compiler floor for contributors is 11 as documented, not whatever your organisation has standardised on.
Obfuscation is opt-in, so a default build is not a release build
The build command is the standard Maven one, and the artifact lands in target.
$ mvn clean installPackaging takes a different command, and its output goes somewhere specific.
$ mvn clean packageResults appear in the target sub-folders of the assemblies modules. The README gives one worked example of the path: a Desktop Client distribution under the client assembly, named pdi-ce-*-SNAPSHOT.zip. Note what that name says. A default build produces a snapshot, and separately the README notes that -Drelease can be added to trigger obfuscation and/or uglification as needed. So the archive you get by following the quick path is neither a versioned release nor obfuscated, and the two gaps compound: you can hand a colleague a zip that is both unreleased and un-obfuscated without any warning in the filename.
Two test lifecycles, and two different skip switches
Unit tests run under the test phase and the README says they cover the project and its sub-modules.
$ mvn testIntegration tests, which it describes as testing cross-module operation, need verify plus an opt-in flag.
$ mvn verify -DrunITsBoth can be narrowed to a single test. For a unit test the README drops you into core first and opens a remote debug port, 5005 by default.
$ cd core
$ mvn test -Dtest=<<YourTest>> -Dmaven.surefire.debugThe integration equivalents add -Dit.test and -Dmaven.failsafe.debug. Two skip switches also appear in different sections, -DskipTests alongside the tests and -Dmaven.test.skip=true in the build section, and the README does not say how they differ. If you are trying to make a failing build go away rather than fix it, that ambiguity is where an hour disappears. To keep a record of a build, redirecting output to log.txt is the documented route.
Contributing means a Jira case, a patch file and checkstyle
The contribution flow is the strictest thing in the README. A pull request must reference the relevant Jira case, and a Git patch file has to be attached to that same Jira case. On top of that the Pentaho checkstyle format is expected, checked with the following and a read of the resulting report.
$ mvn checkstyle:checkWorking unit tests are what the README says gets a pull request processed quickly, and it hands you two ClassRules for keeping a test environment clean. RestorePDIEnvironment lives under core/src/test/java/org/pentaho/di/junit/rules, RestorePDIEngineEnvironment under engine/src/test/java/org/pentaho/di/junit/rules, and the README assigns them to core and engine tests respectively.
public class MyTest {
@ClassRule public static RestorePDIEnvironment env = new RestorePDIEnvironment();
#setUp()...
@Test public void testSomething() {
assertTrue( myMethod() );
}
}The practical effect for an outside contributor is that a patch without a Jira case has no documented path through, which is a process obstacle before it is a technical one.
Carte's API doc and JMeter plan sit in the root, undocumented in the README
The repository root contains CarteAPIDocumentation.md and Carte-jmeter.jmx, which are the two files that tell you this project ships a server side as well as a desktop client. A markdown API description and a JMeter test plan for it are in-tree, so the HTTP surface of the server is meant to be exercised rather than guessed at.
None of it is reachable from the README. The build and run instructions cover Maven, packaging and tests, and stop there. There is no section on starting Carte, no statement of the port it binds, and no mapping between the API document and a running service, and the only port number the README mentions anywhere is 5005 for remote debugging. If your requirement is a scheduled server-side ETL runner rather than a desktop tool, you are relying on a document in the tree and the community forum to work out the deployment, which is a materially different risk from building the modules yourself.
Translation scripts and a jmeter plan, the unglamorous half
Three root entries describe work that no feature announcement mentions. translator.xml, translator.sh and Translator.bat are the localisation toolchain, present as a config file plus a Unix script plus a Windows batch file, so the same translation step has to be runnable on both platforms a contributor might use. Carte-jmeter.jmx is a load test plan checked into the tree.
The consequence is about maintenance surface rather than features. The translator files are not documented in the README and the build section does not invoke them. The load plan matters for the same reason in reverse: a performance claim about the server is something you would generate with that file rather than assume, and the README attaches no expected numbers to it.
A 2015 customer patch is the only release tag in the repository
The last push to this repository landed on 2026-11-02, and work on master is recent. Version history is a different story. The only release the repository publishes is 5.2.0.2-C-185-R, described as a 5.2.0.2 CUST-185 patch, tagged on 2015-01-06. A customer-specific patch from eleven years ago is not a shipping cadence, it is a leftover, and it means tags tell you nothing about which build anyone should run.
That is consistent with the README's packaging example, which is a SNAPSHOT. So if you are standing up PDI from this tree, you are running code whose version string carries no promise, and the README documents no release channel, no supported distribution and no upgrade path. For support it points at the Hitachi Vantara community forum. On licensing, the root carries LICENSE.TXT and the README says nothing further about it, so whether your use is covered is a question for whoever owns your compliance sign-off, answered before the build lands on a server rather than after.
Editorial conclusion
Build Pentaho Kettle from source when you need to change core, engine, engine-ext or a core plugin and can accept owning your own build, and use a packaged release instead when you only need to run transformations. Verify two things first: that mvn clean install resolves with the Pentaho settings.xml in place on JDK 11, and what your organisation's policy says about LICENSE.TXT, whose terms the README never states.
Frequently asked questions
what is pentaho kettle
Pentaho Data Integration, also known as Kettle, is a Java ETL project built with Maven. Its modules cover the core implementation, the PDI engine and its extensions, the user interface, the database dialog, core plugins, integration tests and the distribution archive.
is pentaho kettle open source
The repository contains a LICENSE.TXT file at its root and is built and published from its own source tree, but the README does not state which license that file holds or what permissions it grants, so check the file itself before relying on it.
is pentaho kettle free
The README does not discuss price, editions or licensing terms anywhere. The only support channel it points at is the Hitachi Vantara community forum for Pentaho products.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/pentaho-pentaho-kettle)Star history chart for your README
[](https://hysenlabs.com/projects/pentaho-pentaho-kettle)Was this useful?