In terms of functionality, either conda or mamba should work. I'd generally choose mamba over conda as mamba is faster than conda, but some may prefer conda as it is a more mature project.
conda is implemented in python, and therefore is not the fastest implementation possible. mamba is not a wrapper on conda, but a partial re-implementation that is focused on performance. mamba is written in C++, does parallel downloading of repository data and package files using multi-threading, and utilizes libsolv for much faster dependency solving. mamba utilities some of the conda code base for tasks that are not critical to performance and therefore mamba has a dependency on python.
Another option is micromamba, which is a purely C++ re-implementation of conda and does not have a dependency on python. If you are creating a new image from scratch and you do not need python in your image, then you should use micromamba to keep your resulting image small. The image mambaorg/micromamba is a good starting point (full disclosure, I am the lead maintainer of this image).
As of March 16, 2022, it is possible to use mamba's solver from within conda.
Answer from Will Holtz on Stack OverflowConda versus mamba in 2024
brew's micromamba provides mamba as well as
Help needed choosing / installing micromamba
Conda to micromamba in dockerfile
Videos
After a couple of instances where conda simply could not install a package, I switched to mamba and haven't really looked back. However, I recently got a new machine and installed the latest version of miniconda on it, and it appears to be really fast now? Is it time to go back to conda?
Any experiences and thoughts are welcome!
[Common] Lisp has several package managers - quicklisp, ultralisp, clpm, osicl, qlot, clpm, cl-micropm - and possibly more.
However, all of these are primarily made for Lisp and can make it difficult to manage non-Lisp dependencies. This extends to scientific computing as well as (non-browser) GUI applications. Python has had similar problems with pip and thus, conda was born. Some find anaconda bloated, and so, there is miniconda. I find miniconda slow, and was searching for better alternatives. Came across micromamba and found it blazingly fast compared to conda and is more-or-less backward compatible with conda.
I'm interested in packaging for conda/micromamba but I'm just starting to learn how the package and channel structures actually work - what parts are generated, what parts need to be supplied by the user, in what format, which aspects of an existing package are conventions vs rules, how do they affect how the package is installed, what does this mean for packaging lisp compilers, etc. I wondered if anyone was already familiar with it or even interested in it.
PS: I have come across guile guix. And perhaps, there might be atleast these two divisions within the community (if I may call us that) - those who want to use guile vs those who do not. If I understand guile correctly, its functional nature implies that each package has its separate environment which contains its dependencies. In other words, the number of dependency versions is proportional to the number of packages (or perhaps, even exponential!). And that's okay when the number of packages or your-primary-projects is half a dozen or less. It seems bloat when that exceeds two dozen! Even if one considers hard links and soft links, the "all packages work together" seems like an artificial requirement imposed over guile's way of managing packages. So, I feel inclined towards quicklisp-like package management - dependencies resolved* during the creation of package index, or conda/micromamba-like runtime dependency resolution. Even if that means sometimes packages won't be installed together. Of course, if someone convinces me otherwise, I'd be happy to use guile instead of micromamba!
*Well, quicklisp doesn't exactly bother with dependencies. But because it tests whether packages load is close enough for the slow-moving lisp world.