16 ms·

Asdf – language tool version manager

• presentation 4y ago
  I discovered this tool a couple years ago since I’d type asdf into Google to test my internet and it started topping the results list. Great tool!
• rektide 4y ago
  Rarely have I seen a tool adopted so swiftly and at such scale. It eats the role of hundreds of other language & tool specific version managers, and whatever the secret sauce is, it's nicely fast & relatively low pain. Hats off to asdf. Major major delta in devs lives from this recent-ist new more-meta contender.
  • viraptor 4y ago
    > whatever the secret sauce is, it's nicely fast Mostly by reusing existing version managers, which have been developed and optimised over the years. Asdf itself is a relatively thin wrapper really.
    • sweetgiorni 4y ago
      I don't think I've even seen an asdf plugin that directly uses a version manager. They generally seem to either A) download prebuilt binaries or B) fallback to building from source. Either way the installs go straight to ~/.asdf/installs. The only exception I can think of is any dependencies on libraries that may or may not be installed by the system package manager. Even then, those dependencies are often optional.
      • viraptor 4y ago
        Yeah, I should've been more precise. The asdf plugins use parts of existing systems. For example (python/ruby/node)-build which mostly come from other version managers. Asdf does provide extras, but the plugin-specific code is tiny: https://github.com/asdf-community/asdf-python/blob/master/bin/install https://github.com/asdf-community/asdf-python/blob/master/bi...
      • eproxus 4y ago
        The Erlang plug-in does this. It uses the older and well-tested Kerl under the hood, but you the nice UI of asdf on top instead.
  • drdaeman 4y ago
    `asdf` is a great tool but I'd like to remind people that it's probably a smart idea to be agnostic to it, for the very same reasons they should've been agnostic to their previous technologies of choice that `asdf` had replaced.
    • crawl_soever 4y ago
      I have an issue out to make it agnostic of keyboard layouts if that helps! https://github.com/asdf-vm/asdf/issues/930 https://github.com/asdf-vm/asdf/issues/930
      • metadat 4y ago
        alias aoeu='asdf' Seems like a reasonable shortcut compared to trying to do keyboard layout detection.
      • hyperupcall 4y ago
        Hmm, yeah I saw that one. Still don't think the motivation is super strong
  • qbasic_forever 4y ago
    The secret sauce is a low barrier to entry. An asdf tool is just a shell script that does the work to list packages, download and install them, etc. You can make a simple tool script in an afternoon. The low barrier to entry is also a bit of a curse too. The quality of asdf tool scripts varies wildly. Anything not maintained by their core org is a crapshoot in my experience. Many of those smaller tools don't support ARM or have lots of undocumented dependencies or quirks.
• tpict 4y ago
  I wonder how many millions of lines of shell configuration have died by people switching to asdf. Fantastic tool
  • stanislavb 4y ago
    Yeah, what is more... it is really helpful and easy to use. Given that I work with Ruby, JS/node & Elixir, it's been such a pleasure to have one tool managing all packages.
  • linux2647 4y ago
    Ironically, it’s written as a shell script
• pmontra 4y ago
  I also use it to run different versions of PostgreSQL without having to use docker.
  • sodapopcan 4y ago
    Oh sheet, I never realized you could do that! Thank you.
• rubyist5eva 4y ago
  Been using this for years, one of my favourite tools. Ruby, nodejs, python, golang, even direnv - all managed seamlessly. Never had problems with it when things like rvm or nvm would just break one day for no reason, never had it happen with Asdf.
• pawelduda 4y ago
  One version manager to rule them all
• javier2 4y ago
  Does it support java?
  • bitwarrior 4y ago
    Yes
  • e12e 4y ago
    Yes: https://github.com/halcyon/asdf-java https://github.com/halcyon/asdf-java
• matsemann 4y ago
  While asdf solves lots of pains, I still feel it solves the wrong problem. What I've instead started to do is to build docker images for various needs. Like, multiple of our projects need terraform, but all different versions. A project should then include that in its dev-dockerfile. No setup, just git clone a project and ready to go. No messing around with "to install and run X you need to have Y already installed, which half of you don't so for some reason it wont work in your environment".
  • kubanczyk 4y ago
    > No setup, just git clone a project and ready to go. Okay, a worthy target. > No messing around I will list layers that I guess you are using: docker client binary a command to run the thing <--- user-specific docker configuration docker daemon as root system-specific dockerd configuration Dockerfile embedded in it, a small shell script to download Terraform binary <--- files scattered on /var/lib/docker/* which never require cleanup dns implementation virtual bridge and other kernel-ish entities tcp proxy a running Terraform binary <--- I marked the layers that, in my opinion, would be enough to achieve the same goal. The explanation is that terraform is a self-contained binary that is not trying to scan system-wide or homedir-wide for files that can and will break it into dozen pieces. It is confined to the repo.
  • e12e 4y ago
    Works well without docker installed, does it? ;)
  • JamesSwift 4y ago
    Agreed, I tend to treat my raw system as read-only and I much prefer it this way. Not only do I get the reproducibility, I also get the ability to more easily prune unused software.
  • nicoburns 4y ago
    That’s all well and good if you’re on Linux, but docker is super slow on Mac and windows. I’ve often worked places that develop iOS apps, s were stuck on macs, and thus alternatives to docker are very welcome. Asdf can automatically install tool chain versions based on a plain text file stored in your repository, so it’s pretty plug and play too.
• AbraKdabra 4y ago
  How does this compare to volta.sh? EDIT: Besides being only for JS.
  • lobo_tuerto 4y ago
    Exactly.
• happens 4y ago
  I've written a rust version of asdf over the last few months, both as an exercise and to fix a few issues I've been having with it - like noticeably slower tool startup times due to the shims resolving the version (my version basically works like direnv under the hood and hooks into the shell directly) and me just wanting a single "use" command which installs a plugin, downloads the requested version and sets it as active. It works very well and I've been daily driving it for a while. Having the ecosystem of asdf plugins which are basically just shell scripts has been a huge boon. It's been a breeze to work with, and most of the plugins are well written. Now, I've been contemplating switching to NixOS, but most version managers don't work at all with it due to dynamic linking. I absolutely love the idea of NixOS, but this has really bummed me out. I feel like the nix language is still a little clunky for general use, so as long as there is not a straightforward solution like having a tool-versions file I'm really hesitant to make the full switch.
  • jasonpeacock 4y ago
    There was a recent post about asdf performance from the maintainer that is quite illuminating: http://stratus3d.com/blog/2022/08/11/asdf-performance/ http://stratus3d.com/blog/2022/08/11/asdf-performance/
    • happens 4y ago
      I feel like they're just hitting the limits of a bash+shims based approach. I understand why they've done it, but in the end an implementation in a compiled language will beat that approach most of the time. There are issues since a shell hook will only work as long as you're, well, using a (supported) shell. However, it's surprising to hear that they've been focusing on UX. The fact that you have to manually install a plugin, then install a version, and then finally set it, without the tool suggesting any of those steps to you when you forgot one, really makes the tool annoying to use when switching versions a lot.
      • eproxus 4y ago
        I don’t agree. As a proof of concept I wrote a Fish native version of the function that figures out what local version of a tool to use I do actually use it to show the currently selected version in my shell prompt. The asdf version was unusable in a shell prompt. It goes through the parent directory structure up until the top level root directory and finds the first .tool-versions file and parses out the version of a specific tool. The asdf native shim takes ~100 ms in Bash (no idea if it can be optimized, but I assume so). My Fish version takes ~1 ms.
• f8 4y ago
  Used this at my last company. Super painless and makes setup a breeze. Current company uses Docker and I hate it. Every company I've been at loves to throw everything into a container. Even if you setup your dev configs to maintain hot reloading, it's always slower. Node package management is also a pain no matter how you implement it with Docker it seems. I also hate the Docker tagline that it "eliminates 'works on my machine' issues". I believe a tool like asdf would also achieve this (correct me if I'm wrong). Docker itself can go haywire depending on the machine and you're basically in hell fighting with it just to get your dev environment working. You essentially eliminate one problem in exchange for a variety of equally frustrating challenges.
  • jhardy54 4y ago
    > I believe a tool like asdf would also achieve this (correct me if I'm wrong). This is true for very simple applications, where you’re just running `npm ci` or `pip install`, but breaks down as soon as you have sophisticated dependencies with system / library requirements or dependencies (e.g. databases, caches, message brokers, queues) that are beyond the scope of asdf. Also, since you’re probably deploying containers to production, it’s useful to have a similar environment for local development so that you know what will actually happen in production.
    • jen20 4y ago
      > since you’re probably deploying containers to production Citation needed I feel - I’d wager the number of containerized deployments pales in comparison to the number of binaries scp’d into a production host.
      • jhardy54 4y ago
        I’d also be interested to know the answer! I said “probably” because the vast majority of deployments I’ve done over the past decade have been containerized, but I have no trouble believing that my experience isn’t indicative of the average.
    • 999900000999 4y ago
• felipelalli 4y ago
  In a very quick & dirty read I couldn't understand what it's for. Could someone give me a practical example? I think a practical example is lacking in the introduction.
  • brigandish 4y ago
    I feel your pain, I always upvote people who summarise links on HN because so often the linked info leaves me in the dark! There was a discussion about asdf before[1] with a blog post[2] about someone's shift to using asdf which may help, it's pretty straight to the point. [1] https://news.ycombinator.com/item?id=30917354 https://news.ycombinator.com/item?id=30917354 [2] https://jinyuz.dev/2020/07/switching-from-pyenv-rbenv-goenv-and-nvm-to-asdf/ https://jinyuz.dev/2020/07/switching-from-pyenv-rbenv-goenv-...
  • bxparks 4y ago
    My problem is that I know what it's for, but I don't understand how it works. The referenced page contains a "How It Works" section, but it gives me no useful information: > Once asdf core is set up with your Shell configuration, plugins are installed to manage particular tools. When a tool is installed by a plugin, the executables that are installed have shims created for each of them. When you try and run one of these executables, the shim is run instead, allowing asdf to identify which version of the tool is set in .tool-versions and execute that version. There is a hyperlink on word shims to the Wikipedia article https://en.wikipedia.org/wiki/Shim_(computing) https://en.wikipedia.org/wiki/Shim_(computing) that explains the generic concept of shims. Not helpful.
    • rzzzt 4y ago
      Most likely $PATH and variables like eg. $JAVA_HOME get modified so that asdf captures any invocation to commands like "python" in the shell, and runs its own code instead of /usr/bin/python. Then it can decide which version of Python to defer to. Edit: here it is: https://github.com/asdf-vm/asdf/blob/v0.10.2/asdf.sh#L30-L31 https://github.com/asdf-vm/asdf/blob/v0.10.2/asdf.sh#L30-L31
  • letmeinhere 4y ago
• teilo 4y ago
  After the pain of pyenv and it's terrible compatibility with poetry, asdf has been a dream come true. It just works, every time. No fragile config. No mess.
  • hyperupcall 4y ago
    What sort of compatibility issues exist with pyenv and poetry? Curious as I've never mixed the two...
    • GOATS- 4y ago
      One of the things Pyenv let's you do is to use a specific version of Python within a folder. Poetry will sometimes fail to detect it and use whatever version is used globally instead.
      • hyperupcall 4y ago
        Thanks, that is quite unfortunate
• Cloudef 4y ago
  Just use nix and write shell.nix file.
  • kimburgess 4y ago
    This is horrible advice. Use a flake.nix
    • Cloudef 4y ago
      I haven't ever needed flakes myself, but I guess this was sarcasm as it's nix eitherway :)
      • kimburgess 4y ago
        Oh yes sorry, there was an implied /s there.
  • viraptor 4y ago
    Not sure if /s was implied here, but there's an issue with this. Specific versions of most runtimes require hunting for repos that replicate the xyz-build tools but for nix. There isn't a nix-native version of "give me ruby 2.3.4" (unless you want to dig through history and hope it was included). So yeah, there's https://github.com/bobvanderlinden/nixpkgs-ruby https://github.com/bobvanderlinden/nixpkgs-ruby and others - but you have to find them yourself. (until someone makes a flake to integrate them all, I guess?)
    • ar_lan 4y ago
      There is always the option of writing your own derivation for specific versions too, however. I don't think mentioning Nix is meant to be sarcastic - this is a function the package manager has built-in by default, so it is worth mentioning.
    • Cloudef 4y ago
      There's lots of ways nix can be used. It's framework and shell.nix lets you build any sort of environment you want. E.g. if you don't want to use the nixpkgs ruby, you could install rvm in the env and in the shellhook get the correct ruby. Or use the nixpkgs-ruby as you found out. It's relatively easy to pull any sort of nix libraries into your own .nix file (and even easier with flakes). The most powerful thing about nix is that every derivation is cached, so now you can have your own binary cache shared somewhere, and suddenly everyone's build times go down, especially useful for complicated dev environments. For example, I cross-compile rust code to arm64, build websites, and deploy the whole infrastructure to AWS including the said rust code as AWS lambdas from a single nix derivation. The cross-compiling toolchains, etc take time to build, but then they are cached and only stuff that gets rebuild are the actual stuff I'm developing / changing. This is the backbone of nix really. You may not think this is not that amazing though, but nix is from ground-up built so that it's very difficult to write anything impure, anything that can't be cached or does not cache properly. For my work, I've written shell.nix for every project I'm developing. This means my own personal environment stays clean, but for projects I always have the environment I need up in seconds. And if I start running out of space, I can just run nix-collect-garbage and forget about it. This is especially useful for me, as I do contract work and don't use the work PC just for one company. I haven't actually yet used NixOS, but if I ever have to spin up new servers, I'm considering it.. I have ryzen machine that I use for gaming and sometimes building larger stuff... and I'm feeling like I want to migrate that to NixOS.. maybe someday .. :) Also if you are an mac user, you really should do yourself a favor and switch away from homebrew
• SighMagi 4y ago
  It’s also super easy to integrate with non-POSIX shells, if you’re into that kind of thing.
• denolfe 4y ago
  I have been using asdf for quite a few years, and I've always been impressed. It's honestly a breath of fresh air to only have a single set of commands to remember for node, go, ruby, python, even crystal. For node, it even respects existing .nvmrc files.
  • dogweather 4y ago
    Yep. I love being able to do `asdf install`, and it goes through the .tool-versions and installs everything needed.
• seandoe 4y ago
  Great tool. I love it. Thanks!
• password4321 4y ago
  Love this. Can never remember the syntax for installing plugins vs. specific versions without double-checking though.
  • neurostimulant 4y ago
    Nothing wrong with not remembering syntax for a rarely-used functionality. It's not like you install a plugin every day to warrant a muscle memory. I use tar once or twice a month and still need to double check the parameters.
  • sundarurfriend 4y ago
    `tldr-pages` has a page for asdf, as a quick and easy reference for these common operations. Web interface: https://tldr.ostera.io/asdf https://tldr.ostera.io/asdf Other clients (ways to access it): https://github.com/tldr-pages/tldr/wiki/tldr-pages-clients https://github.com/tldr-pages/tldr/wiki/tldr-pages-clients
• letmeinhere 4y ago
  One tip that I didn't know about and didn't seem to be documented at the time I was looking: if you want to add a plugin for some new project but just defer to what you were already using for everything else, you can set your `global` option to `system`. e.g.: asdf global python system
  • lamontcg 4y ago
    The one thing I really miss from rvm is the ability to do this only in the current session rather than globally.
    • kyleashipley 4y ago
      I might be missing something, but I think you can use `asdf shell` for this: https://asdf-vm.com/manage/commands.html https://asdf-vm.com/manage/commands.html
      • lamontcg 4y ago
        Oh, that's exactly what I wanted, yes.
• deleted 4y ago
  [deleted]
• mattpallissard 4y ago
  Have a project that requires multiple versions of terraform? what? you don't want to... clone the terraform source repo ~ git remote -v origin https://github.com/hashicorp/terraform.git (fetch) origin https://github.com/hashicorp/terraform.git (push) check out the tag you want ~ git tag | tail -1 v1.1.5 ~ git checkout v1.1.5 Previous HEAD position was 516295951 Release v1.1.4 HEAD is now at fe2ddc22a Release v1.1.5 compile/install the binary in a local bin dirctory, ~ go build go: downloading github.com/aws/aws-sdk-go v1.42.35 ~ install terraform ~/bin/terraform-v1.1.5 ~ ls ~/bin/terraform\* /home/matt/bin/terraform /home/matt/bin/terraform-v0.13.7 /home/matt/bin/terraform-v1.1.4 /home/matt/bin/terraform-v0.13.4 /home/matt/bin/terraform-v0.14.9 /home/matt/bin/terraform-v1.1.5 then manage a series of brittle aliases to disptach the proper version? ~ which terraform terraform () { binary=terraform if [[ $1 == "v"\* ]] && [[ $1 != "validate" ]] then version=$1 shift binary="$binary-$version" [ -f ~/bin/$binary ] || bail 1 "missing binary $binary" || return 1 else binary=/usr/bin/$binary fi dispatch --name terraform --scope --slice compilers.slice -c 35 -mh 2048M -mm 2048M -s 1M --binary $binary "$@" } (dispatch just runs things with memory and cpu limits) ~ which dispatch dispatch () { if [[ $USER == "root" ]] then command "$binary" "$@" return $? fi declare args=(--user --same-dir -p IOAccounting=yes -p MemoryAccounting=yes -p TasksAccounting=yes) while (($#)) do case "$1" in (-c) args+="-p" args+="CPUWeight=$2" shift 2 ;; (-mm) args+="-p" args+="MemoryMax=$2" shift 2 ;; (-mh) args+="-p" args+="MemoryHigh=$2" shift 2 ;; (-s) args+="-p" args+="MemorySwapMax=$2" shift 2 ;; (--scope) args+=--scope shift ;; (--slice) args+="--slice=$2" shift 2 ;; (--name) name=$1 shift 2 ;; (-P) args+=-P shift ;; (--binary) [ -z "$name" ] || name=$2 binary="$2" shift ;; (*) break ;; esac done systemd-run $args "$@" 2> >(>&2 grep -vE 'Running.*as unit:') } and of course, then you'd need a shitty little script to call your alias when other tools decide they want to call terraform ~ cat ~/bin/terraform #!/usr/bin/env zsh source ~/.zshrc >/dev/null 2>/dev/null || exit 1 terraform $@ Because that would be silly and dumb, and I totally don't do that for everything. Don't even get me started on virtualenvs.
  • kubanczyk 4y ago
• robertwt7 4y ago
  I love asdf, switched from nvm, jenv, pyenv to one tool Sadly this is not available in windows so i had to use WSL to run everything. Development in windows is so wonky once you switched from unix based system
• anonyme-honteux 4y ago
  Is ASDF supposed to work with fish and macOS? My boss loves ASDF and I liked the idea but I tried to use it three times and failed
  • necessary 4y ago
    This is my setup, and it works great! Install was flawless aswell, no trickery needed on my behalf. What problem did you run into?
    • anonyme-honteux 4y ago
      I gave it another try and it works asdf which node /Users/jmfayard/.asdf/installs/nodejs/19.0.0/bin/node which node /Users/jmfayard/.asdf/shims/node node --version v19.0.0 asdf local nodejs 16.18.0 node --version v16.18.0 I probably had read the documentation in the wrong order. Thanks for your message!
  • spike021 4y ago
    I just joined a company in the past few months that uses Macs and pretty much all dev environment documentation insists on using ASDF. I had a lot of problems, and am still having one or two, in a few of the codebases I need to work in. I think the main thing is just having consistent documentation, especially for global settings. But other than that it definitely "works" on MacOS; can't comment on fish, I use zsh.
  • bostonvaulter2 4y ago
    Yes it does! Although I recommend not installing asdf via homebrew and installing it via git instead. It makes updating more seamless.
  • dogweather 4y ago
    Yep, I use adsf and fish on MacOS installed via Homebrew. Works great.
• hiyer 4y ago
  Love asdf. Been using it for python, java and ruby for some time and it does away with the pain of having multiple version managers. Highly recommend.
• dboreham 4y ago
  I get on better with sdkman, fwiw.
• throwawaaarrgh 4y ago
  Downside: it's all shell scripts. Upside: it's all shell scripts. Seriously through, it's pretty easy to create an asdf plugin, and it works great. But it would be great if there were a static executable to handle it all. A couple projects out there come close, but need people to contribute code to finish the most useful functionality. One example is https://github.com/marcosnils/bin https://github.com/marcosnils/bin - the developer is fully in favor of improvements and added features, but needs someone with the free time to add them.
• maltalex 4y ago
  Can anyone suggest a comparable tool for dotnet?
• ephaeton 4y ago
  "ASDF (Another System Definition Facility) is an extensible build facility for Common Lisp software. ASDF comes bundled with all recent releases of active Common Lisp implementations as well as with quicklisp, and it is the most widely used system definition facility for Free Software Lisp libraries." Does asdf come with a plugin for asdf & quicklisp? would've preferred for the new guy on the block pay respect to the old guy on the block and used a different name..
  • derrida 4y ago
    Yeah really not a great name choice hey. asdf for common lisp been around for years and used by the clergy of programming basically and still widely used today
• ivolimmen 4y ago
  I tried asdf and direnv in the past but they did not cut it when working with Java and Java related tooling. direnv was slow and asdf does not have all the tooling I needed and use. I started using sdkman.io for Java development and it is very complete, up to date and speedy.
  • Maphistow 4y ago
    What tooling were you missing working with asdf and java?
• phtrivier 4y ago
  Probably the only sane way to install Erlang / elixir. Sadly, reuses the name of a completely unrelated common lisp tool.
• thunfisch 4y ago
  I've been using this at work, sharing with my colleagues, and integrating this into our default CI/CD environment. It's awesome and has taken away the thought of "how do I install version XYZ of tool ABC here?" entirely. Just asdf what I need, done. Huge productivity boost.
• bluehatbrit 4y ago
  I'm a big fan of asdf, I switched to it from nvm back when I found it and was using node. To be honest I don't use it much anymore because I've mostly converged on vscode dev containers. But anything I need to do directly on my local machine or for running the odd random tool it's a life saver. Dealing with things like nvm, n, rbenv, and kerl were such a pain before.
• Existenceblinks 4y ago
  Good to see it's still kicking, longevity is hard in cli space for non OS built-in ones. Works great in itself, however, PostgreSQL version upgrade is quite hustle. It's plug-in area, though could have some protocol with the core to make it seamless. I didn't upgrade my postgres for a while (on 12.4 right now). Not sure if it still requires you to do: `POSTGRES_EXTRA_CONFIGURE_OPTIONS=--with-openssl LDFLAGS="-L/usr/local/opt/openssl/lib" CPPFLAGS="-I/usr/local/opt/openssl/include" asdf install postgres x.x` And run `pg_upgrade` yourself moving data from previous version to the new one's directory.
• tjoff 4y ago
  I've been qurious about asdf for a while, but looking at the plugins I don't find anything about gcc or clang for instance (but quriously cmake). Though asdf itself is language-agnostic, is it in practice used more for web-development or something?
  • augusto-moura 4y ago
    The plugins are community based, plugins are created on a need. It looks like most people don't want to mess up with multiple gcc/libc versions installations
    • tjoff 4y ago
      Or, those that do don't use asdf for whatever reason.
• derrida 4y ago
  Being a bit of a tool myself I'd like to define a .toolfile for the whole internet: Convert all data / markup to s-expressions Make all code lambda calculus in some paren form No more "xml being manipulated by a scheme designed to look like imperative language" (javacript manipulating the DOM) Thank you have a nice day.
• samgranieri 4y ago
  I've used this for six years on macOS. It's been working nicely.
• mvaliente2001 4y ago
  asdf is very nice, with the exception of its interface. You have `asdf <context> <command>`, `asdf <command> <package>` for others. It's actively hostile for memorisation.