rbenv VS rye

When I was technical blogging on how to learn from open-source code [1], I used it quite frequently to get unstuck and/or to figure out how to tease apart a large question into multiple smaller functions. For example, I had no idea how to break up this long `sed` command [2] into its constituent parts, so I plugged it into ChatGPT and asked it to break down the code for me. I then Googled the different parts to confirm that ChatGPT wasn't leading me astray.

If I had asked StackOverflow the same question, it would have been quickly closed as being not broadly applicable enough (since this `sed` command is quite specific to its use case). After ChatGPT broke the code apart for me, I was able to ask StackOverflow a series of more discrete, more broadly-applicable questions and get a human answer.

TL;DR- I quite like ChatGPT as a search engine when "you don't know what you don't know", and getting unblocked means being pointed in the right direction.

1. https://www.richie.codes/shell

2. https://github.com/rbenv/rbenv/blob/e8b7a27ee67a5751b899215b...

Let’s get started. I prefer to manage my Ruby installations on my development machine with chruby paired with ruby-install. Another outstanding set of tools is rbenv with ruby-build. I highly recommend installing Ruby with one of those two sets of tools. Follow the instructions on their project’s READMEs. For this article, I’ll be running Ruby (MRI) v3.3.0.

By setting up your environment in isolation, you can prevent yourself from a lot of issues when experimenting with code. It makes your code behave more predictable due to the defined state of the runtime environment you are working with. This article should provide you with enough information to get started, but obviously, there is a lot more power embedded in NVM, Virtual Environment and RBEnv. So make sure to check their documentation.

There is this good resource that also talk about different ruby version manager from the Rbenv repository. With some links to benchmarks of ASDF and Rbenv.

rbenv (my personal favorite)

One suggestion would be to setup your install based on a development environment using git and a Ruby version manager like rvm or rbenv to allows you to setup a user controlled gemset and execution path.

rbenv for Ruby

git clone https://github.com/rbenv/rbenv.git ~/.rbenv

On MacOS, I haven't had a problem with character encodings in the terminal in ruby for a while, but used to. When I used to, it had to do with how ruby had been installed, in particular that it needed to be compiled linking against an appropriate readline library. Are you trying to use the ruby that came with debian? You might have more luck installing ruby yourself, and using a ruby version manager. rbenv might be the simplest for you.

For my local machine, I use RVM (head). Other options are rbenv and asdf.

I tried out rye + uv on a recent greenfield project. They are awesome tools and I'm really excited about their potential.

For me, rye (+ uv underneath) has perhaps the perfect workflow for an open source Python project. So I'm definitely using rye for that from now in -- instead of, say, poetry -- or hatchling directly, following the PyPA boilerplate[1].

You have a way of doing local development against any Python interpreter version. You have a way of tweaking dependencies. It all works atop "standard" PyPA infrastructure like pyproject.toml. You have a single command to build[1] project artifacts, like wheels. And you have a single command to publish new artifact versions to PyPI[2].

I think if you're doing local development on a project that is not meant to be published to PyPI, like a private Django project, then whether to use rye becomes more of a debate. For example, for a Django project I'm working on, I decided to just use uv directly, along with a Makefile. This is because during development of a Django project, I preferred to just use a plain requirements.txt (really, requirements.in) file, avoid the sync/lock workflow that rye imposes, and avoid the need to use something like rye run. And rye's ability to package didn't solve a problem since the Django project wasn't being deployed via a PyPA packaging mechanism.

But this is probably also because the Python interpreter/venv management problem, for me, is already handled by pyenv. I think if you're not already a pyenv user, rye is even more appealing because it handles "all" of the Python issues -- interpreters, requirements/dependencies, and packaging/publishing. (As well as a number of other standard issues besides, like testing, linting, and formatting.) But, in my case, I could hand venv management to uv, and then make dependency management part of a larger Makefile for my Django project, including custom linting, testing, and deployment steps. I wrote a little bit about my high level thoughts on Python packaging and dependency management, though this post was written before rye and uv were out.[4]

I'll also say, I found a little bug in how rye (+ hatch) interacted with my local git setup, and reported it to the rye team, and they helped me get to the bottom of it rather quickly.[5]

[1]: https://packaging.python.org/en/latest/tutorials/packaging-p...

[2]: https://rye-up.com/guide/commands/build/

[3]: https://rye-up.com/guide/commands/publish/

[4]: https://amontalenti.com/2022/10/09/python-packaging-and-zig

[5]: https://github.com/astral-sh/rye/issues/793

I've been using Rye[0] lately, which has been pretty good. It's really just a wrapper around a bunch of underlying tools - it's nice to not have to worry about those and let Rye do it's thing.

All that being said, the creator of Rye is 100% cognizant of that XKCD comic, this [1] is a nice read.

I'm not super well versed in Python tooling at all. I've had to work a lot in Python in the past 6+ months, and I become super confused when I tried making a Python project in my spare time.

I settled on Rye because it just seemed to be the easiest to use.

[0]: https://rye-up.com/

I think Rye actually does handle this mostly correctly (as the sibling comment said). I got through some of it here: https://github.com/mitsuhiko/rye/issues/671. I think actually it's very close to what I actually want (maybe not what Armin wants with multiversion).

Rye[1] is an all in one manager for python projects. Including the python versions and virtualenv, pip etc etc... It seperates tool deps from app deps. Its all configured through a pyproject.toml config file.

Its still new but works well. I'm transiting to it from an unholy mess of pyenv, pip installs and other manual hacks.

If you're starting a new python project that is more than just a straightforward script I'd use Rye from the get go.

[1]https://rye-up.com/

Your first comment irked me because it adds zero value to the discussion. You lazily threw out XKCD 927 which the Rye author explicitly mentioned themselves.

If you click into their link "Should Rye Exist" [1] you'll see that XKCD 927 is literally the first sentence and full width image.

[1] https://github.com/mitsuhiko/rye/discussions/6

Try Rye.

Since this is a discussion on dependency management in Python - does anyone use rye [0] regularly now? I'm interested in using it but want a little more social validation before I try - some issues with package managers only appear after you've invested considerable time.

[0]: https://rye-up.com/

The short term solution is "relieving the packaging pain" link in the article.

The long term solution is described in the "What a solution could look like?" section of https://www.bitecode.dev/p/why-is-the-python-installation-pr...

The community is buzzing with attempts to fix those issues this year, so I’m hopping those posts will become obsolete one day.

Flask’s author is attempting something interesting with rye: https://github.com/mitsuhiko/rye

Trio’s author is drafting a spec for the equivalent of wheels, but for the whole python interpreter: https://github.com/njsmith/posy/blob/main/pybi/README.md

Not advocating to use them right now, but the fact is bootstrapping Python is finally acknowledged as one major cause of packaging issues and a priority to solve.

I'm building a package manager for Python (Rye) in Rust and it is modeled after cargo and rustup. It like rustup manages itself. This means it has commands such as rye self update which downloads the latest version and swaps itself out. Likewise there is rye self uninstall which uninstalls rye itself.