Dependencies

 elide install

Elide detects which ecosystems are in play (from your elide.pkl and from any foreign manifests present), resolves them, and installs everything into your project's .dev/dependencies directory.

Why it's built this way

One toolchain, many ecosystems

Most projects are already polyglot — a TypeScript frontend, a Python data script, a JVM service — and each ecosystem normally drags in its own package manager, its own daemon, its own cache, and its own version skew. Elide collapses all of that into the runtime you already have. The npm and PyPI resolvers are compiled directly into the binary, so resolution is a function call, not a subprocess: no Node, no CPython, no pip bootstrap, no JVM spin-up just to download a jar.

Security-first defaults

npm and PyPI resolution route through pkg.st by default — Elide's hardened package proxy (npm.pkg.st, pypi.pkg.st). Installs are reproducible: aube writes aube-lock.yaml, the JVM resolver records artifacts in the project lockfile, and the npm store is content-addressed. You can opt out of the proxy at any time with the global --no-pkgst flag to hit upstream registries directly.

Compatibility by default

Python dependencies are resolved against Elide's own embedded interpreter, not whatever Python happens to be on your PATH. Because Elide runs GraalPy, uv selects wheels that are compatible with the GraalPy ABI — so packages you install are the packages that will actually import and run under elide. The same principle holds across ecosystems: what elide install resolves is exactly what elide run will load.

Declaring dependencies

Unified manifest (elide.pkl)

The native way to declare dependencies is the elide.pkl project manifest. A single dependencies { } block holds all three ecosystems:

amends "elide:project.pkl"

name = "my-app"

dependencies {
  npm {
    packages {
      "react@19.0.0"
      "@scope/widget@1.2.3"
    }
    devPackages {
      "typescript@5.6.2"
    }
  }

  pypi {
    packages {
      "six==1.17.0"
      "requests>=2"
    }
  }

  maven {
    packages {
      "com.google.guava:guava:33.4.8-jre"
    }
  }
}

npm and PyPI specifiers use their native syntax (name@version, name==version / name>=version). For the full set of Maven dependency buckets (modules, testPackages, compileOnly, repositories, …), see Elide Projects → Dependencies.

Foreign manifests

You don't have to convert an existing project. Elide reads the ecosystem manifests you already have, and treats any of them as a project-root marker:

• npm — package.json
• PyPI — requirements.txt, pyproject.toml

# A directory with just a package.json and a requirements.txt:
 elide install

Foreign manifests and elide.pkl can coexist. When both are present, Elide resolves the union. (Direct pom.xml resolution is not yet supported — declare Maven dependencies in elide.pkl for now.)

Where things land

Install options

$  elide install                 # resolve & install every detected ecosystem
$  elide install --slim          # JVM: skip sources/javadoc classifiers
$  elide install --with sources  # JVM: also fetch a specific classifier
$  elide install --fresh         # ignore caches and re-resolve from scratch

Using the tools directly

The embedded resolvers are also exposed as first-class subcommands. Anything after -- is passed straight through to the underlying tool, so you get the full aube / uv / Maven CLI through elide:

# aube (npm) — Elide's embedded Node.js package manager
 elide aube -- install --ignore-scripts
 elide aube -- --help

# uv (PyPI) — Elide's embedded Python package manager
 elide uv -- pip install rich
 elide uv -- --help

# Maven — Elide's native-image Maven runner
 elide mvn -- dependency:tree

Global flags such as --no-pkgst go before the subcommand (elide --no-pkgst aube -- install); tool flags go after --.

Platform support

See also

• Elide Projects — the elide.pkl manifest in depth
• NPM Installer — npm/aube specifics
• Elide + Python — running Python and resolving PyPI deps
• Maven Installer — JVM dependency details