A modern programming language that makes developers happier.

kotlinlang

i see.. what should i do for a multi module project ? i want to not redeclar adependencies in every module but i also do not want to leak them fro mthe library

You should redeclare dependencies only if you actually use those dependencies in this module and this is reasonable explicit approach. Use implementation when it's possible to better encapsulation of modules

how is a loop going to work for dependencies ?

<@UBBFK40RZ>
```
val configurationsToConfigure =
    setOf(configurations["config1"], configurations["config2"])

dependencies {

   val dependency = create("some.dependency.here:somename:someversion)

   configurationsToConfigure.forEach {
       (it)(dependency)
    }
}
```

interesting but i feel liek that does not solve my problem of wanting to  have dependencies transitibvely available within the lib across modules but not bleeding them outside

but the alternative is to have a lot of duplicatiuion.. or a dependency net

<@UBBFK40RZ>
In your root project `build.gradle.kts` file:
```
val projectsToConfigure = setOf(project(":A"), project(":B"))

configure(projectsToConfigure) {

    dependencies {
        "compile"("some.dependency.here:somename:someversion")
    }
}
```

i see, that is smart
i  thought of doing something where i do
```
allpprojects { configureDependencies() }
```

and then a `when` going over all subprojects to set up dependencies

and for dependencies on projects it can do a recursive call to set up all dependencies
then i can organize it later.. since its all in one file

Yea, that works.
Your root project generally doesn’t have any source code, so you probably want to use:
```
subprojects { configureDependencies() }
```

I recommend not putting source code in your root project when you have a multi-project build.

i honestly do not remember why i did organize it that way, i guess rethinking the multimodule layout goes on the todo

&gt; wanting to  have dependencies transitibvely available within the lib across modules
Could you explain your case?