import org.gradle.groovy.scripts.ScriptSource
import org.gradle.kotlin.dsl.support.loggerFor


internal
class KotlinScriptPlugin(
    private val scriptSource: ScriptSource,
    private val script: (Any) -> Unit
) : ScriptPlugin {

    override fun getSource() =
        scriptSource

    override fun apply(target: Any) {
        logger.debug("Applying Kotlin script to {}", target)
        script(target)

 * limitations under the License.
 */

package org.gradle.jvm.application.scripts;

import java.io.Writer;

/**
 * Generates a script to start a JVM application.
 *
 * @see TemplateBasedScriptGenerator
 */
public interface ScriptGenerator {

    /**
     * Generate the script.
     * <p>
     * Implementations should not close the given writer.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.
It is either a `settings.gradle` file written in Groovy or a `settings.gradle.kts` file in Kotlin.

The link:{groovyDslPath}/index.html[Groovy DSL^] and the link:{kotlinDslPath}/index.html[Kotlin DSL^] are the only accepted languages for Gradle scripts.

The settings file is typically found in the root directory of the project.

		})
}

// Stop returns a sentinel error that causes script execution to halt
// and s.Execute to return with a nil error.
func Stop() Cmd {
	return Command(
		CmdUsage{
			Summary: "stop execution of the script",
			Args:    "[msg]",
			Detail: []string{
				"The message is written to the script log, but no error is reported from the script engine.",
			},
		},

    implements FileAccessTimeJournalFixture {

    @UnsupportedWithConfigurationCache(because = "tests script compilation")
    def "cleanup deletes old script cache entries"() {
        given:
        requireOwnGradleUserHomeDir()
        executer.requireIsolatedDaemons()

        and: 'seed script cache to have a baseline to compare against'
        buildKotlinFile.text = """
            tasks.register("run") {

import org.gradle.jvm.application.scripts.JavaAppStartScriptGenerationDetails
import org.gradle.util.internal.TextUtil
import org.gradle.util.internal.WrapUtil
import spock.lang.Specification

class UnixStartScriptGeneratorTest extends Specification {

    UnixStartScriptGenerator generator = new UnixStartScriptGenerator()

    def "classpath for unix script uses slashes as path separator"() {
        given:

import org.gradle.plugin.use.PluginDependenciesSpec
import kotlin.script.experimental.annotations.KotlinScript
import kotlin.script.experimental.api.baseClass
import kotlin.script.experimental.api.filePathPattern
import kotlin.script.experimental.api.implicitReceivers
import kotlin.script.templates.ScriptTemplateDefinition


private

The choice between script, precompiled script, or binary plugins depends on your specific requirements and preferences.

*Script Plugins* are simple and easy to write.
They are written in Kotlin DSL or Groovy DSL.
They are suitable for small, one-off tasks or for quick experimentation.
However, they can become hard to maintain as the build script grows in size and complexity.

import org.gradle.configuration.ScriptPlugin
import org.gradle.groovy.scripts.ScriptSource


internal
class DeclarativeDslPlugin(
    private val scriptSource: ScriptSource,
    private val script: (Any) -> Unit
) : ScriptPlugin {

    override fun getSource() =
        scriptSource

    override fun apply(target: Any) {
        script(target)
    }

├── shared
│   ├── src
│   │   └──...
│   └── build.gradle
└── settings.gradle
----
<1> Create the `MyCustomTask` task.
<2> A shared build script.
<3> Uses the `MyCustomTask` task and shared build script.
=====

In the `buildSrc`, the build script `shared.gradle(.kts)` is created.
It contains dependencies and other build information that is common to multiple subprojects:

[.multi-language-sample]
=====