When building “multi-module” projects with Jenkins CI, Jenkins, Nexus/Artifactory & Maven cooperate so that only the minimal set of modules is built. For large projects this is crucial, and makes the difference between fast several minute CI and slow several hours build.

I am seeking to reach the same build performance with gradle and multi-project.
(1) Is there a way to build only a subset of the sub-projects and their dependent sub-projects (similar to maven flags -pl and -am)
(2) Is there any jenkins integration so that indeed only these sub-projects will be invoked?
(3) If not - has anyone found a different way to replicate this behaviour based on a gradle plugin / task?

I think you are just talking about incremental build. Simply ensure you don’t do a clean or delete the Jenkins workspace between builds and you will get the behavior you want. Gradle will only rerun tasks whose inputs have changed. You can test this locally by doing gradle build changing a file in one of your subprojects and building again. The behavior you should see is that only the project that changed (and those that depend on it) should be built.

No, there is actually a big difference.
With incremental build you do not clean up your workspace, which may lead to various issues (different discussion).
With maven multi module CI using jenkins, you always clean up (“mvn clean deploy”) - but since jenkins passes the list of modules that changed you get a minimal build. And since maven identifies inter-module dependencies - you get a consistent build.

It really is a very important feature for large projects, and if you would like further explanations I will gladly have a 1x1 discussion and show you how it works.
I like Gradle, but this is a major drawback when working on large projects (think hundreds of sub projects).

How does Jenkins determine which modules have changed, is it just based on VCS paths? Can you point me at some documentation as to how this works? If a Jenkins plugin is simply passing an argument list to the build tool I see no reason why this type of integration could not be possible with Gradle. It would just be a matter of implementing it.

(1) Jenkins analyzes POM to determine what modules are part of the build
(2) It then checks which files have changed in the last commit, and maps
these to modules
(3) It them passes maven the list of changed modules (-pl m1,m2,m3,…) and
(4) requests “also make dependents” (-amd)