Made with Lisp
Ogamita ergo · Free & open source

Point it at a git repo. It builds, reproducibly.

A git-native package manager and project builder for Common Lisp and AutoLISP — no central registry, no lock-in, just repositories and lock files.

Dependency management for Common Lisp normally means a central curated distribution, refreshed on someone else's schedule. ergo makes the git repository itself the unit of distribution. Any repo, public or private, is a project or a dependency: track a branch, or freeze a tag, release, or exact commit.

A lock file records the whole dependency graph at exact commits, so a teammate or a CI runner rebuilds byte-identical sources, months or years later, without asking a registry for permission first.

How It Works

One command to fetch, build, and load any Lisp system straight from its git repository. A project file when you want to pin versions and declare how to build, test, and run.

1. Build anything, by name or URL

$ ergo build github:sharplispers/split-sequence
$ ergo build gitlab:alexandria/alexandria@latest
$ ergo run  https://gitlab.com/me/my-app.git -- --help

2. Describe a project in my-app.ergo

(ergo:project
 :designator   (git "https://gitlab.com/me/my-app.git")
 :dependencies ((github "sharplispers/split-sequence" :tag "v2.0.1")
                (gitlab "alexandria/alexandria" :tag :latest))
 :build (asdf "my-app")
 :test  (asdf "my-app/test")
 :run   (lisp "(my-app:main)"))

Build, test, and lock the graph:

$ ergo build   # resolves the graph, fetches, compiles
$ ergo test    # ...and writes my-app.erglock -- commit it
$ git add my-app.erglock   # reproducible for everyone, forever

Why ergo

Dependency management that inherits everything git already gives you — history, signatures, private hosting, exact commits — instead of reinventing it behind a registry.

No central registry

Any git repository, public or private, is a project or a dependency. Nothing to register, nobody to ask.

Pin to anything

Track a branch, or freeze a tag, release, or exact commit. Your choices, recorded in a lock file.

Reproducible builds

The .erglock file captures the whole dependency graph at exact commits, so every teammate and CI runner rebuilds identical sources.

Polyglot

Common Lisp (ASDF) and AutoLISP (ALPM), plus shell and make builders — one tool for AutoCAD, BricsCAD, clautolisp, and SBCL/CCL alike.

Find things by name

A built-in name index generated from the Quicklisp catalogue resolves about 2,300 libraries by bare name, plus live search of the GitHub and GitLab APIs.

HTTPS by default, SSH to hack

Anonymous read-only fetches work everywhere, including CI with no keys. Add --ssh when you mean to edit and push a dependency.

Offline & CI friendly

A shared cache of bare mirrors plus an --offline flag. The core has no Quicklisp dependencies at all.

Diamonds handled

Conflicting version requirements are detected and resolved by explicit rules — no silent surprises.

Three interfaces

The ergo shell command, the ERGO Common Lisp package, and the ergo-* AutoLISP functions — the same operations everywhere.

How ergo compares

The Common Lisp ecosystem has excellent tools already. ergo's bet is different: make the git repository the unit of distribution, and let per-project lock files do the pinning — the way modern polyglot build tools work.

ergo Quicklisp Qlot ocicl CLPM
Unit of distribution any git repo central curated dist ql dist + qlfile OCI registry configured sources
Central registry required No Yes Yes (a dist) a registry optional
Per-project version pinning branch / tag / release / commit dist snapshot only qlfile.lock per-system lockfile
Lock file yes (.erglock) no yes yes yes
Private / self-hosted repos any git host + native auth awkward via git in qlfile registry auth yes
Languages Common Lisp + AutoLISP (+ shell) Common Lisp Common Lisp Common Lisp Common Lisp
Discovery by name Quicklisp-derived index + host API search central index via ql index registry listing source index
Transport git (https / ssh) https tarballs https OCI git / https

Not a competition so much as a different center of gravity: ergo doesn't replace the Quicklisp catalogue — it reuses it for name resolution, so you are never worse off for discovery, and you gain exact-commit pinning, private repos, and AutoLISP in the same tool.

Get Started

Build from source and install into any prefix.

1. Install

$ git clone https://gitlab.com/ogamita/ergo.git
$ cd ergo
$ make build
$ sudo make install   # PREFIX=/opt/local by default

2. Use it

$ ergo init gitlab:me/my-app   # scaffold a project
$ ergo build                  # fetch + compile the graph
$ ergo test                   # ...and write the lock file
$ ergo where-is alexandria    # where's the clone?

Common Lisp: (ergo:load "gitlab:me/my-app") · AutoLISP: (ergo-load "gitlab:me/my-autolisp-lib")

The complete walkthrough — repository designators, the project file, the Common Lisp and AutoLISP packages, and the full command reference — is the user manual: read it here as a single page or paginated, one section per page. It also installs as an Info page (info ergo) and ships as HTML and PDF alongside the sources. Prefer a packaged download to a checkout? Get it from the releases page.

Licensing

ergo is free software, free to use, study, modify, and redistribute.

AGPL-3.0-or-later

No dual licensing, no commercial tier — ergo is released under the GNU Affero General Public License. If you run a modified version reachable over a network, your modifications must be made available to its users.

Questions & consulting

Bug reports and merge requests are welcome on GitLab. For quick questions, join #clergo on Libera.Chat IRC — the botergo bot answers common ones. For integration help, AutoLISP builder work, or a support arrangement, write to Ogamita.