How do I manage dependencies in EK9?

EK9 manages dependencies as a first-class language feature inside `defines package`.

No separate build file (pom.xml, Cargo.toml, go.mod) is needed. Everything lives in your .ek9 source file.

Package metadata:

  version as Version: 1.0.0-0          semantic version with build number
  description as String = "..."         what the package does
  license <- "MIT"                      license identifier
  tags <- [ "tools", "networking" ]     categorization tags
  publicAccess <- true                  visible to other packages

Dependencies use Dict literals:

  deps <- {
    "ekopen.network.utils": "1.6.1-9"
  }

Dev-only dependencies (not included in production):

  devDeps <- {
    "ekopen.test.helpers": "2.0.0-0"
  }

Exclude transitive dependencies:

  excludeDeps <- {
    "unwanted.transitive.dep": "ekopen.network.utils"
  }

CLI commands for the dependency lifecycle:

  ek9 -Dp app.ek9             resolve dependencies (cleans first)
  ek9 -Dp -v app.ek9          resolve and show accepted/rejected deps
  ek9 -I app.ek9              install to local library cache
  ek9 -P app.ek9              package for deployment (uses -O3)
  ek9 -D app.ek9              deploy (triggers -P and -Gk if needed)
  ek9 -Gk app.ek9             generate signing keys

Version management:

  ek9 -IV minor app.ek9       increment minor version
  ek9 -SV 2.0.0 app.ek9       set version explicitly
  ek9 -PV app.ek9             print current version

Version format: MAJOR.MINOR.PATCH-BUILD (e.g., 1.0.0-0)
Feature branches: MAJOR.MINOR.PATCH-FEATURE-BUILD (e.g., 1.0.0-beta-5)

Semantic versioning is enforced:
- Same MAJOR.MINOR: highest PATCH is auto-selected
- Different MAJOR: build fails (breaking API change)
- Circular dependencies are detected and rejected

The code example below shows a complete package definition with dependencies.

See Q8 for tagging packages for discovery. See Q9 for licensing. See Q10 for dev vs production dependencies. See Q11 for excluding transitive dependencies. See Q13 for packages vs modules. See Q14 for listing resolved dependencies. See Q15 for semantic versioning. See Q270 for supply chain security.

Example

defines module qa.getting.started.manage.dependencies

  defines package

    version as Version: 1.0.0-0
    description as String = "Example package showing dependency management"
    license <- "MIT"
    publicAccess <- true

    tags <- [
      "example",
      "getting-started"
    ]

    applyStandardIncludes <- true

    deps <- {
      "ekopen.network.support.utils": "1.6.1-9",
      "ekopen.net.handy.tools": "3.2.1-0"
    }

    devDeps <- {
      "ekopen.org.supertools.util": "4.6.1-6"
    }

    excludeDeps <- {
      "ekopen.some.unwanted.pack": "ekopen.org.supertools.util"
    }

  defines program
    ManageDependencies()
      stdout <- Stdout()

      stdout.println("Package with dependencies defined")
      stdout.println("Run: ek9 -Dp thisFile.ek9 to resolve")
      stdout.println("Run: ek9 -PV thisFile.ek9 to see version")

Other ways to ask this

How do I add a library dependency?
How do I declare package dependencies?
What is defines package in EK9?
How does EK9 handle third-party libraries?
How do I publish or deploy an EK9 package?
What replaces pom.xml or build.gradle in EK9?
I use Maven/Gradle for dependencies, how does EK9 handle this?

Coming from another language?

Python: pip/requirements.txt/pyproject.toml. Java: Maven pom.xml or Gradle build.gradle. Rust: Cargo.toml [dependencies]. Go: go.mod require directives. Node: package.json dependencies. EK9 embeds all of this directly in the source file as a language construct, not a separate configuration format.

Keywords: devDeps, start, install, cargo, publish, gradle, first, intro, beginner, pip, semantic, mvn, deps, maven, pom, package, npm, import, versioning, deploy, version, dependencies, library