Gradle plugins#

There are three. Add only the ones you need.

plugins {
	application
	id("io.jimble.jte") version "2.7.6"
	id("io.jimble.run") version "2.7.6"
	id("io.jimble.db")  version "2.7.6"
}

They are not on the Plugin Portal. They come from Maven Central, so write the repository into settings.gradle.kts (the jimble new skeleton already has it).

pluginManagement {
	repositories {
		mavenCentral()
		gradlePluginPortal()
	}
}

Writing it from scratch#

If you are not using jimble new, these two files are enough. What follows was actually run (gradle build chains migrate → codegen → compileJava, and gradle run starts the app).

// settings.gradle.kts
pluginManagement {
	repositories {
		mavenCentral()
		gradlePluginPortal()
	}
}

rootProject.name = "memo"

// build.gradle.kts
plugins {
	application
	id("io.jimble.jte") version "2.7.6"   // if you use src/main/jte
	id("io.jimble.run") version "2.7.6"   // if you want hot reload
	id("io.jimble.db")  version "2.7.6"   // if you use a database
}

repositories {
	mavenCentral()
}

// jimble is built for Java 25. Without this the dependencies will not resolve
java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(25)
	}
}

dependencies {
	implementation("io.jimble:jimble-web:2.7.6")

	testImplementation(platform("org.junit:junit-bom:5.11.4"))
	testImplementation("org.junit.jupiter:junit-jupiter")
	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.withType<Test>().configureEach {
	useJUnitPlatform()
}

// Add conf/ to the resources. Config and migrations are both read from there ([Configuration](./config))
sourceSets {
	main {
		resources {
			srcDir("conf")
		}
	}
}

application {
	mainClass = "memo.App"
}

jimbleRun {
	mainClass = "memo.App"
}

Dependency resolution is looking for a library compatible with JVM runtime version 21,
but 'io.jimble:jimble-web:2.7.6' is only compatible with JVM runtime version 25 or newer

Which artifact to depend on#

You do not write down what comes along for the ride (add jimble-web and you get jimble-db and jimble-util too).

You do not need a JDBC driver — jimble-db carries MySQL / MariaDB and PostgreSQL.

io.jimble.db#

./gradlew migrate       # apply the SQL that has not been applied
./gradlew codegen       # build the table definition classes (after migrate)
./gradlew codegenCheck  # check the committed generated code against the schema

What they do is in Migrations and code generation.

jimble {
	sourceRoot   = "src/main/java"   // where generated code goes
	env          = "local"           // passed to the CLI as -Denv=...
	autoGenerate = true              // wire it in front of compileJava?
}

So migrate → codegen → compileJava is wired only locally. It is not wired in CI, which compiles straight from the committed generated code.

./gradlew build -Pjimble.autoGenerate=true    # when you want it wired in CI too

When codegenCheck finds drift, it fails and says this.

コミットされている生成物がスキーマと一致しません（2 件）。codegen を実行してコミットしてください。
  生成物が古いです: db/blog_example/table/post/Post.java
  生成物が足りません: db/blog_example/table/tag/Tag.java

In English: "The committed generated code does not match the schema (2 files). Run codegen and commit the result." — then, per file, "generated code is stale" and "generated code is missing".

io.jimble.jte#

The .jte files under src/main/jte are turned into Java. compileJava compiles them, so a type error in a template fails the build (Templates).

jte {
	sourceDirectory       = "src/main/jte"
	packageName           = "gg.jte.generated.precompiled"
	contentType           = "Html"    // Html | Plain
	trimControlStructures = true
	htmlCommentsPreserved = false
}

Only the plugin carries the compiler (gg.jte:jte). The application's runtime classpath gets jte-runtime and nothing else (requirement D-27).

io.jimble.run#

./gradlew jimbleRun

How it works and what to watch out for is in Hot reload. This page is the list of settings.

jimbleRun {
	mainClass = "my_blog.App"        // required
}

What gets watched is src, conf (if it exists), and watchDirs.

When the build fails#

Nothing stops. The failure comes out in the browser.

Fix it, save, reload, and you carry on.

Tasks for AI assistants#

Every jimble plugin (io.jimble.jte / io.jimble.run / io.jimble.db) adds them.

jimbleSkills#

jimble new copies the skills in, so upgrading jimble leaves the copies behind and your application's AI keeps reading the old version's explanations. Run it after you upgrade.

./gradlew jimbleSkills
./gradlew jimbleSkills --overwrite   # also replace hand-edited skills and ones with no record

• Hand-edited skills are never overwritten. The hash of what was placed is recorded in .claude/jimble-skills.properties; a file that still matches (untouched since jimble placed it) is replaced, anything else is left alone
• Skills with no record (placed by a jimble new from before the record existed) are left alone too, since there is no telling whether they were edited. If you did not edit them, use --overwrite
• Put your application's own rules in AGENTS.md, not in the skills. An edited skill can no longer be brought up to date
• AGENTS.md / CLAUDE.md are placed only if missing, never touched otherwise (CLAUDE.md just says @AGENTS.md)

jimbleCheck#

It only looks for things that go wrong silently at run time (anything that fails at startup and tells you how to fix it is left out). Any ERROR fails the task; WARN alone does not.

It also lists 1.x code that 2.0 removed, or whose type or meaning 2.0 changed (all WARN; the rewrites are in Moving to 2.0).

J8xx and J9xx are always listed. --target=2.0 is still accepted so scripts from the 1.5 days keep working, but it does nothing.