diff --git a/.run/CLI build --help.run.xml b/.run/CLI build --help.run.xml
index 98e231ef..15cc637c 100644
--- a/.run/CLI build --help.run.xml	
+++ b/.run/CLI build --help.run.xml	
@@ -1,8 +1,8 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="CLI build --help" type="JetRunConfigurationType">
+  <configuration default="false" name="CLI compile --help" type="JetRunConfigurationType">
     <module name="voodoo-parent.voodoo.main" />
     <option name="VM_PARAMETERS" value="" />
-    <option name="PROGRAM_PARAMETERS" value="build --help" />
+    <option name="PROGRAM_PARAMETERS" value="compile --help" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
     <option name="ALTERNATIVE_JRE_PATH" />
     <option name="PASS_PARENT_ENVS" value="true" />
diff --git a/.run/CLI build --id forgePack.run.xml b/.run/CLI build --id forgePack.run.xml
index 596cfb01..33b969ac 100644
--- a/.run/CLI build --id forgePack.run.xml	
+++ b/.run/CLI build --id forgePack.run.xml	
@@ -1,8 +1,8 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="CLI build --id forgePack" type="JetRunConfigurationType">
+  <configuration default="false" name="CLI compile forgePack" type="JetRunConfigurationType">
     <module name="voodoo-parent.voodoo.main" />
     <option name="VM_PARAMETERS" value="" />
-    <option name="PROGRAM_PARAMETERS" value="--log TRACE build --id forgepack" />
+    <option name="PROGRAM_PARAMETERS" value="--log TRACE compile forgepack/v0.0.1.voodoo.json" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
     <option name="ALTERNATIVE_JRE_PATH" />
     <option name="PASS_PARENT_ENVS" value="true" />
diff --git a/.run/CLI build.run.xml b/.run/CLI build.run.xml
index 415a7149..ae5b180b 100644
--- a/.run/CLI build.run.xml	
+++ b/.run/CLI build.run.xml	
@@ -1,8 +1,8 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="CLI build --id fabricPack" type="JetRunConfigurationType">
+  <configuration default="false" name="CLI compile fabricPack" type="JetRunConfigurationType">
     <module name="voodoo-parent.voodoo.main" />
     <option name="VM_PARAMETERS" value="" />
-    <option name="PROGRAM_PARAMETERS" value="--log TRACE build --id fabricPack" />
+    <option name="PROGRAM_PARAMETERS" value="--log TRACE compile fabricPack/152Version.voodoo.json fabricPack/164Version.voodoo.json" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
     <option name="ALTERNATIVE_JRE_PATH" />
     <option name="PASS_PARENT_ENVS" value="true" />
diff --git a/README.md b/README.md
index 1d136659..9290f883 100644
--- a/README.md
+++ b/README.md
@@ -86,7 +86,7 @@ java -jar voodoo.jar init project
 ./voodoo init pack --id newPack --mcVersion 1.16.2
 
 # builds a pack
-./voodoo build --id mypack
+./voodoo compile newPack/v0.0.1.voodoo.json
 
 # packages for upload
 ./voodoo package --id mypack -p voodoo -p mmc-voodoo -p curse
diff --git a/docs/index.md b/docs/index.md
index e7d385c9..9035e9e5 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -62,20 +62,23 @@ Usage examples
 ==============
 
 ```bash
+# setup wrapper/shell scripts and gitignore
+java -jar voodoo.jar init project
+
 # generate json schema for autocompletion
-java -jar voodoo.jar generateSchema
+./voodoo generateSchema
 
 # create a new pack
-java -jar voodoo.jar create pack --id newPack --mcVersion 1.16.2
+./voodoo init pack --id newPack --mcVersion 1.16.2
 
 # builds a pack
-java -jar voodoo.jar build --id mypack
+./voodoo compile newPack/v0.0.1.voodoo.json
 
 # packages for upload
-java -jar voodoo.jar package --id mypack -p voodoo -p mmc-voodoo -p curse
+./voodoo package --id mypack -p voodoo -p mmc-voodoo -p curse
 
 # launches pack in multimc
-java -jar voodoo.jar launch multimc --id mypack
+./voodoo launch multimc --id mypack
 
 ```
 
diff --git a/docs/quickstart.md b/docs/quickstart.md
index 0981574d..7cb02024 100644
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -228,17 +228,17 @@ so lets add some mods
 
 //TODO: add sections about overrides and properties of entries
 
-## Building the pack
+## Compiling the pack
 
-`building` the pack does resolve all dependencies of entries and pins versions
+`compiling` the pack does resolve all dependencies of entries and pins versions
 
 ```bash
-voodoo build --id magicpack
+voodoo compile magicpack/v0.0.1.voodoo.json
 ```
 
-this created `/magicpack/lock/` folder cotnaining the output artifacts
+this created `/magicpack/lock/` folder containing the output artifacts
 *DO NOT DELETE* this folder unless you know what you are doing
-this folder contains the inputs for all tasks (except `build`)
+this folder contains the inputs for all tasks (except `compile`)
 
 ## Testing in MultiMC
 
diff --git a/samples/fabricpack/lock/0.0.2/lock.pack.json b/samples/fabricpack/lock/0.0.2/lock.pack.json
index b6166aa1..9fd74f41 100644
--- a/samples/fabricpack/lock/0.0.2/lock.pack.json
+++ b/samples/fabricpack/lock/0.0.2/lock.pack.json
@@ -3,7 +3,7 @@
     "mcVersion": "1.15.2",
     "modloader": {
         "type": "Fabric",
-        "loader": "0.11.0",
+        "loader": "0.11.1",
         "intermediateMappings": "1.15.2",
         "installer": "0.6.1.51"
     },
@@ -56,7 +56,7 @@
             "path": "mods",
             "name": "fabric-api",
             "projectID": 306612,
-            "fileID": 3147516
+            "fileID": 3174096
         },
         {
             "type": "curse",
diff --git a/samples/fabricpack/lock/0.0.3/lock.pack.json b/samples/fabricpack/lock/0.0.3/lock.pack.json
index 0673a3d0..526f398f 100644
--- a/samples/fabricpack/lock/0.0.3/lock.pack.json
+++ b/samples/fabricpack/lock/0.0.3/lock.pack.json
@@ -3,7 +3,7 @@
     "mcVersion": "1.16.4",
     "modloader": {
         "type": "Fabric",
-        "loader": "0.11.0",
+        "loader": "0.11.1",
         "intermediateMappings": "1.16.4",
         "installer": "0.6.1.51"
     },
diff --git a/voodoo/src/main/kotlin/voodoo/cli/BuildCommand.kt b/voodoo/src/main/kotlin/voodoo/cli/BuildCommand.kt
deleted file mode 100644
index 484190a6..00000000
--- a/voodoo/src/main/kotlin/voodoo/cli/BuildCommand.kt
+++ /dev/null
@@ -1,193 +0,0 @@
-package voodoo.cli
-
-import com.eyeem.watchadoin.Stopwatch
-import com.eyeem.watchadoin.saveAsHtml
-import com.eyeem.watchadoin.saveAsSvg
-import com.github.ajalt.clikt.core.CliktCommand
-import com.github.ajalt.clikt.core.requireObject
-import com.github.ajalt.clikt.parameters.options.*
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.slf4j.MDCContext
-import kotlinx.coroutines.withContext
-import mu.KotlinLogging
-import mu.withLoggingContext
-import voodoo.builder.Builder
-import voodoo.config.Configuration
-import voodoo.data.lock.LockPack
-import voodoo.pack.MetaPack
-import voodoo.pack.VersionPack
-import voodoo.util.VersionComparator
-import voodoo.util.json
-
-class BuildCommand() : CliktCommand(
-    name = "build",
-    help = ""
-) {
-    private val logger = KotlinLogging.logger {}
-
-    val cliContext by requireObject<CLIContext>()
-
-    val id by option(
-        "--id",
-        help = "pack id"
-    ).required()
-        .validate {
-            require(it.isNotBlank()) { "id must not be blank" }
-            require(it.matches("""[\w_]+""".toRegex())) { "modpack id must not contain special characters" }
-        }
-
-    val versionOptions by option(
-        "--version",
-        help = "build only specified versions"
-    ).multiple().validate { version ->
-        require(version.all { it.matches("^\\d+(?:\\.\\d+)+$".toRegex()) }) {
-            "all versions must match pattern '^\\d+(\\.\\d+)+\$' eg: 0.1 or 4.11.6 or 1.2.3.4 "
-        }
-    }
-
-    val all by option("--all").flag("--newest", "--latest", default = true, defaultForHelp = "only $commandName newest version")
-    val buildMissing by option(
-        "--buildMissing",
-        help = "build versions when lockfiles are missing"
-    ).flag("--skipMissing", default = true)
-//    val rebuildFailing by option(
-//        "--rebuildFailing",
-//        help = "rebuild versions that failed to parse lockfiles, this might overwrite old files"
-//    ).flag(default = false)
-
-    override fun run() = withLoggingContext("command" to commandName, "pack" to id) {
-        runBlocking(MDCContext()) {
-            val stopwatch = Stopwatch(commandName)
-
-            val rootDir = cliContext.rootDir
-
-            require(id.isNotBlank()) { "id must not be blank" }
-
-            stopwatch {
-
-                val config = Configuration.parse(rootDir = rootDir)
-
-                val baseDir = rootDir.resolve(id)
-
-                val metaPackFile = baseDir.resolve(MetaPack.FILENAME)
-                val metaPack = json.decodeFromString(MetaPack.serializer(), metaPackFile.readText())
-
-                val versionPacks = VersionPack.parseAll(baseDir = baseDir)
-                    .sortedWith(compareBy(VersionComparator, VersionPack::version))
-                    .let { versionPacks ->
-                        val latestVersion = versionPacks.last().version
-                        versionPacks.filter { versionPack ->
-                            when {
-                                // versionOptions is set
-                                versionOptions.isNotEmpty() -> {
-                                    // version matches
-                                    versionOptions.any { versionOption ->
-                                        VersionComparator.compare(versionOption, versionPack.version) == 0
-                                    }
-                                }
-                                // --all versions are getting rebuilt
-                                all -> return@filter true
-
-                                // --version is not set and latest version is getting built
-                                versionOptions.isEmpty() && versionPack.version == latestVersion -> return@filter true
-                                else -> {
-                                    val lockPackFile = LockPack.fileForVersion(version = versionPack.version, baseDir = baseDir)
-                                    when {
-                                        // build missing lockfiles
-                                        buildMissing && !lockPackFile.exists() -> true
-//                                        // rebuild parse failures for versions in
-//                                        rebuildFailing && lockPackFile.exists() -> {
-//                                            try {
-//                                                LockPack.parse(lockPackFile, rootDir)
-//                                                // lockpack parsed successfully, can be skipped
-//                                                false
-//                                            } catch (e: Exception) {
-//                                                e.printStackTrace()
-//                                                // lockpack failed parsing, it will be rebuilt
-//                                                true
-//                                            }
-//                                        }
-                                        else -> false
-                                    }
-                                }
-                            }
-
-                        }
-                    }
-
-                versionPacks.forEach { pack ->
-                    val otherpacks = versionPacks - pack
-                    require(
-                        otherpacks.all { other ->
-                            pack.version != other.version
-                        }
-                    ) { "version ${pack.version} is not unique" }
-                    require(
-                        pack.packageConfiguration.voodoo.relativeSelfupdateUrl == null || otherpacks.all { other ->
-                            pack.packageConfiguration.voodoo.relativeSelfupdateUrl != other.packageConfiguration.voodoo.relativeSelfupdateUrl
-                        }
-                    ) { "relativeSelfupdateUrl ${pack.packageConfiguration.voodoo.relativeSelfupdateUrl} is not unique" }
-                }
-
-                val lockPacks = versionPacks
-                    .sortedWith(compareBy(VersionComparator, VersionPack::version))
-                    .map { versionPack ->
-                        withLoggingContext("version" to versionPack.version) {
-                            withContext(MDCContext()) {
-//                                logger.info { "flattening: $versionPack" }
-//                                logger.info { "flattening mods:" }
-//                                versionPack.mods.forEach {
-//                                    logger.info { "$it" }
-//                                }
-                                val modpack = versionPack.flatten(
-                                    rootDir = rootDir,
-                                    id = id,
-                                    overrides = config.overrides,
-                                    metaPack = metaPack
-                                )
-//                                logger.debug { "modpack: $modpack" }
-                                logger.debug { "entrySet: ${modpack.entrySet}" }
-
-
-                                val lockPack = Builder.lock("build v${modpack.version}".watch, modpack)
-
-                                lockPack
-                            }
-                        }
-                    }
-
-
-
-//                val tomeEnv = TomeEnv(
-//                    rootDir.resolve("docs")
-//                ).apply {
-//                    add("modlist.md", ModlistGeneratorMarkdown)
-//                }
-
-//                    if (tomeEnv != null) {
-//                        val uploadDir = SharedFolders.UploadDir.get(id)
-//                        val rootDir = SharedFolders.RootDir.get().absoluteFile
-//
-//                        // TODO: merge tome into core
-//                        "tome".watch {
-//                            Tome.generate(this, lockPack, tomeEnv, uploadDir)
-//                        }
-//
-//                        // TODO: just generate meta info
-//
-//                        Diff.writeMetaInfo(
-//                            stopwatch = "writeMetaInfo".watch,
-//                            rootDir = rootDir.absoluteFile,
-//                            newPack = lockPack
-//                        )
-//                    }
-                //TODO: fold lockpacks
-            }
-
-            val reportDir = rootDir.resolve("reports").apply { mkdirs() }
-            stopwatch.saveAsSvg(reportDir.resolve("${id}_build.report.svg"))
-            stopwatch.saveAsHtml(reportDir.resolve("${id}_build.report.html"))
-
-        }
-    }
-}
\ No newline at end of file
diff --git a/voodoo/src/main/kotlin/voodoo/cli/CompileCommand.kt b/voodoo/src/main/kotlin/voodoo/cli/CompileCommand.kt
new file mode 100644
index 00000000..657150a1
--- /dev/null
+++ b/voodoo/src/main/kotlin/voodoo/cli/CompileCommand.kt
@@ -0,0 +1,154 @@
+package voodoo.cli
+
+import com.eyeem.watchadoin.Stopwatch
+import com.eyeem.watchadoin.saveAsHtml
+import com.eyeem.watchadoin.saveAsSvg
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.requireObject
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.arguments.multiple
+import com.github.ajalt.clikt.parameters.arguments.validate
+import com.github.ajalt.clikt.parameters.types.file
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.slf4j.MDCContext
+import kotlinx.coroutines.withContext
+import mu.KotlinLogging
+import mu.withLoggingContext
+import voodoo.builder.Builder
+import voodoo.config.Configuration
+import voodoo.pack.MetaPack
+import voodoo.pack.VersionPack
+import voodoo.util.VersionComparator
+import voodoo.util.json
+
+class CompileCommand() : CliktCommand(
+    name = "compile",
+    help = "resolves versions of mods and their dependencies, produces lockpack"
+) {
+    private val logger = KotlinLogging.logger {}
+
+    val cliContext by requireObject<CLIContext>()
+
+    val packFiles by argument(
+        "PACK_FILE",
+        "path to .voodoo.json file"
+    ).file(mustExist = true, canBeFile = true, canBeDir = false)
+        .multiple()
+        .validate { files ->
+            files.forEach { file ->
+                require(file.name.endsWith("." + VersionPack.extension)) {
+                    "file $file does not end with ${VersionPack.extension}"
+                }
+            }
+        }
+
+    override fun run() = withLoggingContext("command" to commandName, "packs" to packFiles.joinToString { it.path }) {
+        runBlocking(MDCContext()) {
+            val stopwatch = Stopwatch(commandName)
+
+            val rootDir = cliContext.rootDir
+
+//            require(id.isNotBlank()) { "id must not be blank" }
+
+            stopwatch {
+
+                val config = Configuration.parse(rootDir = rootDir)
+
+                val packs: Map<Pair<String, MetaPack>, List<VersionPack>> = packFiles.map { packFile ->
+                    val baseDir = packFile.absoluteFile.parentFile
+                    val id = baseDir.name
+                    val metaPackFile = baseDir.resolve(MetaPack.FILENAME)
+                    val versionPack = VersionPack.parse(packFile = packFile)
+
+                    val metaPack = json.decodeFromString(MetaPack.serializer(), metaPackFile.readText())
+                    Triple(id, metaPack, versionPack)
+                }
+                    .groupBy(
+                        { it.first to it.second },
+                        { it.third }
+                    )
+                    .mapValues { (_, second) ->
+                        second.sortedWith(compareBy(VersionComparator, VersionPack::version))
+                    }
+
+                packs.forEach { (key, versionPacks) ->
+                    val (id, metaPack) = key
+
+                    //TODO: ensure checks are run on all version packs
+                    versionPacks.forEach { pack ->
+                        val otherpacks = versionPacks - pack
+                        require(
+                            otherpacks.all { other ->
+                                pack.version != other.version
+                            }
+                        ) { "version ${pack.version} is not unique" }
+                        require(
+                            pack.packageConfiguration.voodoo.relativeSelfupdateUrl == null || otherpacks.all { other ->
+                                pack.packageConfiguration.voodoo.relativeSelfupdateUrl != other.packageConfiguration.voodoo.relativeSelfupdateUrl
+                            }
+                        ) { "relativeSelfupdateUrl ${pack.packageConfiguration.voodoo.relativeSelfupdateUrl} is not unique" }
+                    }
+
+                    val lockPacks = versionPacks
+//                        .sortedWith(compareBy(VersionComparator, VersionPack::version))
+                        .map { versionPack ->
+                            withLoggingContext("version" to versionPack.version) {
+                                withContext(MDCContext()) {
+//                                logger.info { "flattening: $versionPack" }
+//                                logger.info { "flattening mods:" }
+//                                versionPack.mods.forEach {
+//                                    logger.info { "$it" }
+//                                }
+                                    val modpack = versionPack.flatten(
+                                        rootDir = rootDir,
+                                        id = id,
+                                        overrides = config.overrides,
+                                        metaPack = metaPack
+                                    )
+//                                logger.debug { "modpack: $modpack" }
+                                    logger.debug { "entrySet: ${modpack.entrySet}" }
+
+
+                                    val lockPack = Builder.lock("build v${modpack.version}".watch, modpack)
+
+                                    lockPack
+                                }
+                            }
+                        }
+                }
+//                    .sortedWith(compareBy(VersionComparator, VersionPack::version))
+
+
+//                val tomeEnv = TomeEnv(
+//                    rootDir.resolve("docs")
+//                ).apply {
+//                    add("modlist.md", ModlistGeneratorMarkdown)
+//                }
+
+//                    if (tomeEnv != null) {
+//                        val uploadDir = SharedFolders.UploadDir.get(id)
+//                        val rootDir = SharedFolders.RootDir.get().absoluteFile
+//
+//                        // TODO: merge tome into core
+//                        "tome".watch {
+//                            Tome.generate(this, lockPack, tomeEnv, uploadDir)
+//                        }
+//
+//                        // TODO: just generate meta info
+//
+//                        Diff.writeMetaInfo(
+//                            stopwatch = "writeMetaInfo".watch,
+//                            rootDir = rootDir.absoluteFile,
+//                            newPack = lockPack
+//                        )
+//                    }
+                //TODO: fold lockpacks
+            }
+
+            val reportDir = rootDir.resolve("reports").apply { mkdirs() }
+            stopwatch.saveAsSvg(reportDir.resolve("compile.report.svg"))
+            stopwatch.saveAsHtml(reportDir.resolve("compile.report.html"))
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/voodoo/src/main/kotlin/voodoo/cli/VoodooCommand.kt b/voodoo/src/main/kotlin/voodoo/cli/VoodooCommand.kt
index 0bf2d46f..b509a4b0 100644
--- a/voodoo/src/main/kotlin/voodoo/cli/VoodooCommand.kt
+++ b/voodoo/src/main/kotlin/voodoo/cli/VoodooCommand.kt
@@ -29,7 +29,7 @@ class VoodooCommand(invocation: String = "voodoo") : CliktCommand(
         versionOption(GeneratedConstants.FULL_VERSION)
         subcommands(
             InitCommand(),
-            BuildCommand(),
+            CompileCommand(),
             ChangelogCommand(),
             PackageCommand(),
             LaunchCommand(),
diff --git a/voodoo/src/main/kotlin/voodoo/cli/init/InitPackCommand.kt b/voodoo/src/main/kotlin/voodoo/cli/init/InitPackCommand.kt
index 30548310..100f5c87 100644
--- a/voodoo/src/main/kotlin/voodoo/cli/init/InitPackCommand.kt
+++ b/voodoo/src/main/kotlin/voodoo/cli/init/InitPackCommand.kt
@@ -68,6 +68,8 @@ class InitPackCommand : CliktCommand(
                     uploadBaseUrl = "https://mydomain.com/mc/",
                 )
 
+                val baseDir = rootDir.resolve(id)
+
                 val versionPack = VersionPack(
                     mcVersion = mcVersion,
                     title = title,
@@ -78,12 +80,13 @@ class InitPackCommand : CliktCommand(
                     mods = listOf(
                         //TODO: add mod samples there
                     )
-                )
+                ).apply {
+                    this.baseDir = baseDir
+                }
 
                 val flatModpack = versionPack.flatten(rootDir, id, metaPack, mapOf())
 
                 // create folders
-                val baseDir = rootDir.resolve(id)
                 require(!baseDir.exists() || (baseDir.isDirectory && baseDir.list()!!.isEmpty())) { "folder $baseDir must not exist or be a empty directory" }
                 baseDir.mkdirs()
 
diff --git a/voodoo/src/main/kotlin/voodoo/pack/VersionPack.kt b/voodoo/src/main/kotlin/voodoo/pack/VersionPack.kt
index fb781149..79153ad0 100644
--- a/voodoo/src/main/kotlin/voodoo/pack/VersionPack.kt
+++ b/voodoo/src/main/kotlin/voodoo/pack/VersionPack.kt
@@ -4,6 +4,7 @@ import com.github.ricky12awesome.jss.JsonSchema
 import kotlinx.serialization.Required
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
 import mu.KotlinLogging
 import voodoo.config.Autocompletions
 import voodoo.data.ModloaderPattern
@@ -31,6 +32,9 @@ data class VersionPack(
 //    val overrides: Map<String, EntryOverride> = mapOf(),
     val mods: List<FileEntry>,
 ) {
+    @Transient
+    lateinit var baseDir: File
+
     companion object {
         private val logger = KotlinLogging.logger {}
         const val extension = "voodoo.json"
@@ -47,6 +51,8 @@ data class VersionPack(
                         transformFileEntry(entry)
                     }
                 )
+            }.apply {
+                baseDir = packFile.absoluteFile.parentFile
             }
         }