Gradle Plugin

Default: "pcf"
Example: outputFormat = "yaml"
The output format to generate. The default output renderer for a module supports the following formats:

Default: file("%{moduleDir}/%{moduleName}.%{outputFormat}") (places output files next to the source modules)
Example: outputFile = layout.projectDirectory.file("config.yaml")
The file path where the output file is placed. Relative paths are resolved against the project directory.

If multiple source modules are given, placeholders can be used to map them to different output files. The following placeholders are supported:

If multiple sources modules are mapped to the same output file, their outputs are concatenated. By default, module outputs are separated with ---, as in a YAML stream. The separator can be customized using the moduleOutputSeparator option.

Example 1: multipleFileOutputDir = layout.projectDirectory.dir("output")
Example 2: multipleFileOutputDir = layout.projectDirectory.file("%{moduleDir}/output") The directory where a module’s output files are placed.

Setting this option causes Pkl to evaluate a module’s output.files property and write the files specified therein. Within output.files, a key determines a file’s path relative to multipleFileOutputDir, and a value determines the file’s contents.

This option cannot be used together with any of the following:

This option supports the same placeholders as outputFile.

For additional details, see Multiple File Output in the language reference.

Default: "---" (as in a YAML stream)
The separator to use when multiple module outputs are written to the same file.

Default: (none)
Example: expression = "topLevelProperty.subValue"
The expression to be evaluated within the module.

This option causes Pkl to evaluate the provided expression instead of the module’s output.text or output.files properties. The resulting value is then stringified, and written to the designated output file.

For example, consider the following Pkl module:

The expression metadata.name evaluates to text my-pod.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: null
Example: junitReportsDir = layout.buildDirectory.dir("reports")
Whether and where to generate JUnit XML reports.

Default: false
Whether to ignore expected example files and generate them again.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: false
Example: generateGetters = true
Whether to generate private final fields and public getter methods rather than public final fields.

Default: null if generateSpringBootConfig is true, "org.pkl.config.java.mapper.Named" otherwise+ Example: paramsAnnotation = "org.project.MyAnnotation"
Fully qualified name of the annotation type to use for annotating constructor parameters with their name.
The specified annotation type must have a value parameter of type String or the generated code may not compile. If set to null, constructor parameters are not annotated. Whether and how constructor parameters should be annotated depends on the library that instantiates the generated classes. For Spring Boot applications, and for users of pkl-config-java compiling the generated classes with -parameters, no annotation is required.

Default: "org.pkl.config.java.mapper.NonNull"
Example: nonNullAnnotation = "org.project.MyAnnotation"
Fully qualified name of the annotation type to use for annotating non-null types.
The specified annotation type must be annotated with @java.lang.annotation.Target(ElementType.TYPE_USE) or the generated code may not compile.

Default: " " (two spaces)
Example: indent = "\t" (one tab)
The characters to use for indenting generated source code.

Default: layout.buildDirectory.dir("generated/pkl/<generator_name>")
Example: outputDir = layout.projectDirectory.dir("src/main/pkl")
The directory where generated classes are placed.

The default places generated sources within the build directory of the project, to avoid sources from being committed into the repository on accident.

Default: sourceSets.main (if it exists; no default otherwise)
Example: sourceSet = sourceSets.test
The Gradle source set that generated code is compiled together with.

For the codegen tasks, the modulePath property defaults to the compilation classpath of this source set, as well as all of the source directories of the resource source directory set of this source set. This setup makes it possible to rely on modules defined in classpath dependencies of your project or in the resources of your project.

For projects which apply the idea plugin and are opened in IntelliJ IDEA, this option determines whether generated sources are marked as test sources (if the source set’s name contains the word "test") or regular sources (otherwise).

Default: false
Example: generateSpringBootConfig = true
Whether to generate config classes for use with Spring Boot.

Default: false
Example: implementSerializable = true
Whether to generate classes that implement java.io.Serializable.

Default: [:]
Example: renames = ["foo.": "com.example.foo.", "bar.Config": "com.example.bar.Config"]
Allows to change default class and package names (derived from Pkl module names) in the generated code.

When you need the generated class or package names to be different from the default names derived from the Pkl module names, you can define a rename mapping, where the key is the original Pkl module name prefix, and the value is its replacement. When you do, the generated code’s package declarations, class names, as well as file locations, will be modified according to this mapping.

The prefixes are replaced literally, which means that dots at the end are important. If you want to rename packages only, in most cases, you must ensure that you have an ending dot on both sides of a mapping (except for an empty mapping, if you use it), otherwise you may get unexpected results:

When computing the appropriate target name, the longest matching prefix is used:

Keys in this mapping can be arbitrary strings, including an empty string. Values must be valid dot-separated fully qualifed class name prefixes, possibly terminated by a dot.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: false
Example: generateKdoc = true
Whether to preserve Pkl doc comments by generating corresponding KDoc comments.

Default: " " (two spaces)
Example: indent = "\t" (one tab)
The characters to use for indenting generated source code.

Default: layout.buildDirectory.dir("generated/pkl/<generator_name>")
Example: outputDir = layout.projectDirectory.dir("src/main/pkl")
The directory where generated classes are placed.

The default places generated sources within the build directory of the project, to avoid sources from being committed into the repository on accident.

Default: sourceSets.main (if it exists; no default otherwise)
Example: sourceSet = sourceSets.test
The Gradle source set that generated code is compiled together with.

For the codegen tasks, the modulePath property defaults to the compilation classpath of this source set, as well as all of the source directories of the resource source directory set of this source set. This setup makes it possible to rely on modules defined in classpath dependencies of your project or in the resources of your project.

For projects which apply the idea plugin and are opened in IntelliJ IDEA, this option determines whether generated sources are marked as test sources (if the source set’s name contains the word "test") or regular sources (otherwise).

Default: false
Example: generateSpringBootConfig = true
Whether to generate config classes for use with Spring Boot.

Default: false
Example: implementSerializable = true
Whether to generate classes that implement java.io.Serializable.

Default: [:]
Example: renames = ["foo.": "com.example.foo.", "bar.Config": "com.example.bar.Config"]
Allows to change default class and package names (derived from Pkl module names) in the generated code.

When you need the generated class or package names to be different from the default names derived from the Pkl module names, you can define a rename mapping, where the key is the original Pkl module name prefix, and the value is its replacement. When you do, the generated code’s package declarations, class names, as well as file locations, will be modified according to this mapping.

The prefixes are replaced literally, which means that dots at the end are important. If you want to rename packages only, in most cases, you must ensure that you have an ending dot on both sides of a mapping (except for an empty mapping, if you use it), otherwise you may get unexpected results:

When computing the appropriate target name, the longest matching prefix is used:

Keys in this mapping can be arbitrary strings, including an empty string. Values must be valid dot-separated fully qualifed class name prefixes, possibly terminated by a dot.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: layout.buildDirectory.dir("pkldoc/<generator_name>")
Example: outputDir = layout.projectDirectory.dir("pkl-docs")
The directory where generated documentation is placed.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: (none)
Example: projectDirectories.from(file("pkl-config/""))
The project directories to create packages for.

Default: (false)
Example: skipPublishCheck.set(true)

Skips checking whether a package has already been published with different contents.

By default, the packager will check whether a package at the same version has already been published. If the package has been published, it validates that the package’s metadata is identical to the locally generated metadata.

Default: project.getLayout().getBuildDirectory().dir("generated/pkl/packages")

The directory to write artifacts to. Accepts the following placeholders:

Default: null
Example: junitReportsDir = layout.buildDirectory.dir("reports")
Whether and where to generate JUnit XML reports.

Default: false
Whether to ignore expected example files and generate them again.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Default: (none)
Example: projectDirectories.from(file("pkl-config/""))
The project directories to create packages for.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.

Same meaning as outputFormat in Module Evaluation.

Same meaning as outputFile in Module Evaluation.

Default: []
Example 1: sourceModules = ["module1.pkl", "module2.pkl"]
Example 2: sourceModules = fileTree("config").include("**/*.pkl")
List of Pkl modules which are used for this operation.

This property accepts the following types to represent a module:

Default: [computed by pkl-gradle]
Example 1: transitiveModules.from files("module1.pkl", "module2.pkl")
Example 2: transitiveModules.from fileTree("config").include("**/*.pkl")

File paths of modules that are directly or indirectly used by source modules.

This property, along with sourceModules, is the set of input files used to determine whether this task is up-to-date or not.

By default, Pkl computes this property by analyzing the imports of the source modules. Setting this property explicitly causes Pkl to skip the analyze imports step.

Including source modules in transitiveModules is permitted but not required. Relative paths are resolved against the project directory.

Default: null
Example 1: projectDir = layout.projectDirectory.dir("pkl")
Example 2: projectDir.fileValue file("/some/absolute/path")

Directory where the project lives.

A project is a directory that contains a PklProject file, which is used to declare package dependencies, as well as common evaluator settings to be applied in the project.

If null, this is determined by searching up from the working directory for a directory that contains a PklProject file, until evalRootDir or the file system root is reached.

Disables loading evaluator settings from the PklProject file.

Disables all behavior related to projects.

Default: null
Example: settingsModule = layout.projectDirectory.file("mySettings.pkl")
The Pkl settings module to use. This property accepts the same input types as the sourceModules property.

If null, ~/.pkl/settings.pkl or defaults specified in the pkl.settings standard library module are used.

Default: ["pkl:", "file:", "modulepath:", "https:", "repl:", "package:", "projectpackage:"]
Example: allowedModules = ["file:"]
URI patterns that determine which modules can be loaded and evaluated. Patterns are matched against the beginning of module URIs. (File paths have been converted to file: URLs at this stage.) At least one pattern needs to match for a module to be loadable.

Default: ["env:", "prop:", "modulepath:", "https:", "file:", "package:", "projectpackage:"]
Example: allowedResources = ["env:", "prop:"]
URL patterns that determine which external resources can be read. Patterns are matched against the beginning of resource URLs. At least one pattern needs to match for a resource to be readable.

Default: [:] (note that Gradle default differs from CLI default)
Example 1: environmentVariables = ["MY_VAR_1": "myValue1", "MY_VAR_2": "myValue2"]
Example 2: environmentVariables = System.getenv()
Environment variables that can be read by Pkl code with read("env:<envVariableName>").

Default: rootProject.layout.projectDirectory
Example 1: evalRootDir = layout.projectDirectory.dir("pkl-modules")
Example 2: evalRootDir.fileValue file("/some/absolute/path")

Root directory for file: modules and resources. If non-null, access to file-based modules and resources is restricted to those located under the root directory. Any symlinks are resolved before this check is performed.

Default: null
Example: evalTimeout = Duration.ofSeconds(10)
Duration after which evaluation of a source module will be timed out. Note that a timeout is treated the same as a program error in that any subsequent source modules will not be evaluated.

Default: [:]
Example: externalProperties = ["myProp1": "myValue1", "myProp2": "myValue2"]
External properties that can be read by Pkl code with read("prop:<propertyName>").

Default: null
Example 1: moduleCacheDir = layout.buildDirectory.dir("pkl-module-cache")
Example 2: moduleCacheDir.fileValue file("/absolute/path/to/cache")
The cache directory for storing packages. If null, defaults to ~/.pkl/cache.

Default: false
Format messages using ANSI color.

Default: false
Disable caching of packages.

Default: files() (empty collection)
Example: modulePath.from files("dir1", "zip1.zip", "jar1.jar")
The directories, ZIP archives, or JAR archives to search when resolving modulepath: URIs. Relative paths are resolved against the project directory.

Default: null
Example: proxy = uri("http://proxy.example.com:1234")
Configures HTTP connections to connect to the provided proxy address. The URI must have scheme http, and may not contain anything other than a host and port.

Default: null
Example: noProxy = ["example.com", "169.254.0.0/16"]
Hosts to which all connections should bypass the proxy. Hosts can be specified by name, IP address, or IP range using CIDR notation.