Dependencies

mino projects use mino.edn as the project manifest. It declares source paths and external dependencies, and the mino binary wires them into the module resolver automatically.

Quick start

Create a mino.edn in your project root:

{:paths ["src"]

 :deps {:utils {:git "https://github.com/yourorg/utils.git"
                :rev "a1b2c3d"}}}

Fetch dependencies:

mino deps

Use them in your code:

(require '[utils.core :as u])
(u/some-function)

That is it. When you run mino file.clj or start the REPL, the resolver automatically finds modules in your :paths directories and fetched dependencies.

Manifest reference

:paths

A vector of directories where require searches for your own source files. Defaults to ["src" "lib"] if omitted.

{:paths ["src" "lib" "resources"]}

This is useful on its own, even without dependencies. It tells mino where to find your code.

:deps

A map from dependency name (keyword) to source coordinate. Two coordinate types are supported:

Path dependencies

Point directly at a local directory:

{:deps {:mylib {:path "../mylib/src"}}}

The path is used as-is for module resolution. No fetching needed.

Git dependencies

Clone a repository at a pinned revision:

{:deps {:utils {:git "https://github.com/org/utils.git"
                 :rev "a1b2c3d4"}}}

The :rev is the commit SHA that pins the dependency. Updating it and running mino deps checks out the new revision.

By default, mino looks for source in the src/ subdirectory of the cloned repo (matching standard project layouts). Override this with :deps/root:

{:deps {:odd-lib {:git "https://example.com/odd-lib.git"
                   :rev "abc123"
                   :deps/root ["lib" "modules"]}}}

Using pure libraries from other ecosystems

Libraries written in pure functional style, without platform-specific interop, can be used as git dependencies directly. The module resolver searches .cljc, .clj, and .cljs in that order, so portable Clojure libraries load directly.

Reader conditionals are supported:

#?(:mino (mino-specific-code)
   :clj  (jvm-specific-code)
   :default (fallback))

This means a library can provide mino-specific code paths alongside its existing implementations.

What works: Pure data manipulation, collection operations, string processing, any code that uses only functions mino implements from clojure.core.

What does not work: Java/JVM interop (.method calls, import, Class/staticMethod), JVM-specific namespaces (clojure.java.io, clojure.java.shell), or features mino has not yet implemented.

Commands

mino deps

Reads mino.edn and fetches all git dependencies into .mino/deps/. Skips dependencies that are already cloned. Checks out the pinned revision every time, so updating :rev takes effect on the next run.

Add .mino/ to your .gitignore. The fetched sources are a cache, not committed.

Auto-wiring

When mino.edn exists in the working directory, the mino binary automatically adds :paths and dependency directories to the module resolver. This applies to mino file.clj and the REPL. No extra flags needed.

Projects without mino.edn behave exactly as before.

Workflow examples

Adding a dependency

# Add to mino.edn:
#   :deps {:newlib {:git "https://github.com/org/newlib.git"
#                   :rev "abc1234"}}
mino deps
# Now (require '[newlib.core :as n]) works

Updating a dependency

# Change :rev in mino.edn to the new commit SHA
mino deps
# The new code is checked out

Re-fetching everything

rm -rf .mino/deps
mino deps

Design notes

The manifest is the lock. All coordinates are exact (pinned revisions, direct paths). There is no lockfile because there is nothing to resolve.
No version ranges. No constraint solver, no transitive dependencies, no registry. Dependencies are direct source coordinates.
Unknown keys are ignored. The manifest already uses :tasks for the task runner; future versions can add :main or other keys without breaking existing projects.
Standalone mode only. When mino is embedded in a host application, the host controls the module resolver and which primitives are available. The deps system is a feature of the standalone binary, not the embeddable library.

Troubleshooting

git: command not found

mino shells out to git for cloning. Install git and ensure it is on your PATH.

repository not found

Check the :git URL. For private repos, ensure your SSH keys or credentials are configured.

rev not found

The :rev must be a valid commit SHA or ref (branch name, tag) in the repository. Run git log in the upstream repo to find the right value.

require cannot resolve module

Check that the library's source is in src/ within its repository. If not, add :deps/root ["lib"] (or the correct path) to the dependency spec.