Library / SDK
TimefoldAI/timefold-solver avatar
TimefoldAI/timefold-solver

Timefold Solver: two Maven group ids in one header

The open source Solver AI for Java and Kotlin to optimize scheduling and routing. Solve the vehicle routing problem, employee rostering, task assignment, maintenance scheduling and other planning problems.

1,872 stars243 forksJavaApache-2.0

At a glance

What is it?
Timefold Solver is an Apache-2.0 constraint solver for Java and Kotlin, developed by the original OptaPlanner team and forked on 20 April 2023. Its front page is a short AsciiDoc file that declares two different Maven group ids, defines an attribute nothing consumes, and states a Maven floor the suggested install commands do not target.
Who is it for?
Timefold Solver is worth adopting if your planning problem fits a constraint solver model and you would rather have the OptaPlanner lineage under Apache-2.0 than a commercial licence, and if you can live with a front page that points rather than describes. Three things to check before you plan around it.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
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.

From daily snapshots

Star history

  • TimefoldAI/timefold-solver1,872 ★ · +83
Star history
Repository2026-09-212026-11-15
TimefoldAI/timefold-solver1.8k1.9k

83 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Two group ids appear in the same header block

The first line of the page sets `:projectKey: ai.timefold:timefold-solver`, and that value feeds the SonarCloud badge and link attributes. A few lines down, the Maven Central version badge queries a different coordinate:

code
https://img.shields.io/maven-central/v/ai.timefold.solver/timefold-solver-bom

That is `ai.timefold.solver` with dots, against `ai.timefold` with a colon in the project key. So the header carries two spellings of the same organisation, one used for the quality dashboard and one for the published artifact. Neither is wrong on its own, since a SonarCloud project key and a Maven group id are different namespaces that do not have to match, but the result is that nothing on the front page gives you the dependency snippet you would paste into a build.

The badge also names a BOM rather than the artifact you would import first. So the front page tells you a bill of materials exists at that coordinate and links the build detail through to a version badge, while the actual getting-started material is two links away: a Getting Started guide and a separate Quickstarts repository to clone. The version numbers themselves are not on this page either; the releases recorded for the project are 2.7.0, 2.6.0 and 2.5.0, tagged `v2.7.0` and titled Timefold Solver 2.7.0.

The front page is AsciiDoc, and one of its attributes is never read

The readme file is `README.adoc`, not Markdown. That is visible in its syntax rather than stated: block macros in the form `image::path[link=...,Alt,align="center"]`, `==` headings, `_italics_`, a trailing `+` used as a hard line break, `----` delimiters around listing blocks, and inline links written `link:CONTRIBUTING.md[Contributing]`. The logo path points into `docs/src/modules/ROOT/images/shared/`, which places the documentation on an Antora-style layout with the front page as one module of it.

Four attributes are declared at the top: `:projectKey:`, `:sonarBadge:`, `:sonarLink:` and `:branch: main`. Three of them are consumed. `{projectKey}` appears inside the `sonarBadge` and `sonarLink` definitions, `{sonarBadge}` is used by three rating badges, and `{sonarLink}` closes them. `{branch}` is not referenced anywhere in the file, so `:branch: main` is declared and left over.

That is a small thing on its own, and it matters more here than it would in a project whose readme is mostly links, because this page is mostly badges. There are seven badge images, two logos and a Sonar block, and the sentences carrying actual information are the description, the three build steps, the editions list and the legal notice.

Maven 3.9.11 is a floor the suggested commands do not target

The build prerequisites are JDK 21 or newer and Maven 3.9.11 or newer, with Sdkman offered as the way to get them. The commands offered do not pin either version:

code
$ sdk install java
$ sdk install maven

`sdk install` with no version resolves to the latest available, so the 3.9.11 floor is a requirement stated in prose and a version the suggested commands do not ask for. If you already have Maven 3.9.9 on your machine, nothing in these steps will tell you that you are below the floor.

Cloning and building are two more blocks:

code
$ git clone https://github.com/TimefoldAI/timefold-solver.git
$ cd timefold-solver
code
$ ./mvnw clean install -Dquickly

Note that the build goes through `mvnw`, the wrapper committed at the root beside `mvnw.cmd` and `.mvn/`, rather than through the system Maven the first step told you to install. And `-Dquickly` is passed without a word of explanation anywhere on the page, so whether it skips tests, skips checks, or narrows the module set is something you discover by building rather than by reading. The JVM support badge states Java 21+, which agrees with the prose.

Integrations are separate modules and the front page names none of them

The top level of the repository is a module tree rather than a single library: `core/`, `persistence/`, `quarkus-integration/`, `spring-integration/`, `service/`, `tools/` and `build/`, alongside `docs/`, `pom.xml`, `mvnw`, `mvnw.cmd`, `.mvn/`, `.gitattributes`, `.gitignore`, `CONTRIBUTING.md`, `CONSTUTION.md`, `context7.json`, `LICENSE.txt` and `README.adoc`.

That list says a persistence layer, a Quarkus integration, a Spring integration and a service module are each separate build artifacts, which is the thing that determines what you actually pull into an application. The readme describes none of them, and neither integration is named there, so a Spring Boot user learns their integration exists from the module directory rather than from the documentation.

Two of the remaining root files are also unexplained. `CONSTUTION.md`, spelled with a `u` after the `t` that `constitution` would carry, is a rules document by convention but says nothing on this page. `context7.json` is a machine-readable file whose name matches an external documentation indexing service rather than anything in the Java build. Neither is mentioned, and neither is in a directory, so their purpose is something you establish by opening them.

This repository is the Community half of a two-edition product

There are two editions of Timefold Solver: Community Edition and Enterprise. The readme is explicit that the Community Edition is this repository, open-source and Apache-2.0 licensed, while the Enterprise Edition is a non-open-source commercial offering that requires a Timefold license to run. A separate page is linked for deciding which one is right for you.

That is a clear boundary and worth reading as the feature boundary it implies. Anything in this repository is Apache-2.0 with no license key, no runtime check and no edition flag. Anything in the other edition carries the same product name, so the two are not distinguishable by artifact name alone, and a search result will not tell you which side you are looking at.

The relationship to OptaPlanner underneath both is also stated rather than implied. Timefold Solver is described as developed by the original OptaPlanner team, so this is a continuation by the same people under a different name and a forked codebase, not a third-party implementation. Read that as context for the API surface: the lineage explains why the module layout and the domain list look the way they do, and it is the reason the license section has to be as explicit as it is.

The fork is dated, attributed, and every source file changed

The legal notice is the most specific paragraph on the page. Timefold Solver was forked on 20 April 2023 from OptaPlanner, which was entirely Apache-2.0 licensed, described in the notice as a permissive license. It is a derivative work of both OptaPlanner and OptaPy, and it includes copyrights of the original creator, Red Hat Inc., affiliates and contributors, all of which were entirely Apache-2.0 licensed.

Three things are asserted together, and they matter separately. The date pins the fork to a point in time. The Red Hat Inc. attribution records that upstream copyright persists in the derived work rather than having been replaced by the new project. And the sentence that every source file has been modified answers the question a permissive-license fork usually raises, namely whether anything here is unchanged upstream code.

A third licence appears below that, in the documentation rather than the code. The documentation icon libraries are tabler icons, used under an MIT license, linked to the icon set's own licence page. So the repository carries an Apache-2.0 code licence, an Apache-2.0 upstream lineage and an MIT documentation asset, with the license file at the root named `LICENSE.txt`.

Quality is three live badges, and the domains list is longer than the summary

Rather than state a quality level, the page links three SonarCloud metrics for the project key: a Reliability Rating, a Security Rating and a Maintainability Rating, the last carried under the metric name `sqale_rating`. All three point at the same dashboard, and all three are live images, so the values on the page are whatever SonarCloud computes at the moment it is rendered rather than a fixed claim anyone has to stand behind.

That is a defensible choice for a library whose quality gates run in CI, and it also means the readme asserts nothing specific. A reader who wants a number has to open the dashboard.

The domain list is where the summary and the detail part company. The project summary names four: vehicle routing, task assignment, employee rostering and maintenance scheduling, closing with other planning problems. The readme body names eight: vehicle routing, employee rostering, maintenance scheduling, task assignment, school timetabling, cloud optimization, conference scheduling and job shop scheduling, and then many more planning problems. School timetabling, cloud optimization, conference scheduling and job shop scheduling appear only in the longer list, so the one-line summary understates the range rather than overstating it. The recorded homepage is `solver.timefold.ai`, written without a scheme in the project metadata, while the logo link in the readme is the same host over plain HTTP.

Editorial conclusion

Timefold Solver is worth adopting if your planning problem fits a constraint solver model and you would rather have the OptaPlanner lineage under Apache-2.0 than a commercial licence, and if you can live with a front page that points rather than describes. Three things to check before you plan around it. The toolchain, because JDK 21 and Maven 3.9.11 are the stated floors and the build goes through the bundled `mvnw` with a `-Dquickly` flag whose effect is not described anywhere on the page. The artifacts, because persistence, Quarkus, Spring and service integration each sit in their own module and the front page names none of them, so your dependency footprint is a decision you make from the module tree rather than from the documentation. And the edition, because this repository is the Community Edition while a separately licensed Enterprise Edition also carries the Timefold Solver name and requires a Timefold licence to run, which matters the moment you need a capability that exists only on the commercial side. Read the legal notice as well. The fork date, the Red Hat Inc. copyrights carried in from OptaPlanner and OptaPy, and the MIT-licensed icon set inside the documentation are all stated plainly, with no ambiguity left to resolve.

Frequently asked questions

What does Timefold Solver need in order to build from source?

JDK 21 or newer and Maven 3.9.11 or newer. The build command given is ./mvnw clean install -Dquickly, which runs through the wrapper committed at the repository root rather than the system Maven.

Which Timefold Solver edition is this repository?

The Community Edition. It is open-source and licensed under Apache-2.0, while the Enterprise Edition is a non-open-source commercial offering that requires a Timefold license to run. Both carry the same product name.

When was Timefold Solver forked from OptaPlanner?

On 20 April 2023. OptaPlanner and OptaPy were entirely Apache-2.0 licensed, the derivative work includes copyrights of Red Hat Inc. and contributors, and every source file has been modified.

Which planning problems does Timefold Solver say it optimizes?

Vehicle routing, employee rostering, maintenance scheduling, task assignment, school timetabling, cloud optimization, conference scheduling and job shop scheduling, followed by many more planning problems.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. TimefoldAI/timefold-solver on GitHub
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/timefoldai-timefold-solver.svg)](https://hysenlabs.com/projects/timefoldai-timefold-solver)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/timefoldai-timefold-solver.svg)](https://hysenlabs.com/projects/timefoldai-timefold-solver)

Was this useful?