hckrnws

This is beautiful! Thank you so much!

When I was primarily using Python, I didn't really "get" Mise. Uh, that's what we have uv for! But it really shines when using things like Node where you want a specific version in each directory, and also want common entrypoints like `mise build` or `mise test` in every repo, regardless of its language(s).

Don't get me wrong: I also adore Just as a task runner. It's what got me off of Make, which is incredibly powerful but somewhat lacking in the DevEx department to say the least. It's probably more "powerful" than Mise's tasks. However, Mise's combination of really good — not astounding, but really good — task runners plus all the tool management stuff is unbeatable for the things I work on.

Just curious, as I am a fan of simple Makefiles, what benefits did you encounter moving from Make -> Just -> Mise?

The biggest jump was from Make -> Just. Just -> Mise was minor in comparison, although enough to persuade me.

Just has a lot of UI/UX improvements over Make, like a way to list available recipes, convenient ways to define command-line parameters to recipes, consistent and easy syntax, and a whole lot of predefined functions and variables to cover common use cases like finding the number of CPUs on the current system, manipulate strings, etc. It doesn't do things that Make can't do, because Make can do anything a shell script can if you don't mind wrestling it into submission. It just does those things much more easily.

But it still has a few warts. Recipes look a lot like a shell script, but they're evaluated separately line-by-line, so you can't set a variable on one line and then read it in another. There are workarounds, but that's the default behavior. And a lot of the time when I'd want a task runner, I also want an environment manager (like uv or cargo or node/npm), so bundling those together matches my workflow better than managing those separately.

I have zero bad to say about Just. It's freaking awesome. If Mise disappeared, I'd go back to using Just. I just prefer Mise right now.

Still, Just can not track target dependencies so it will never replace Make or Bazel.

I see that as an advantage.

Make and Bazel already exist. Just and Mise and other options don’t need to reinvent that wheel. My last employer used Bazel and I liked using Mise as a wrapper around it so that `mise test` invoked the complex command line to run all the tests, kind of like a set of shell aliases that only affect that one repo.

A task runner is not supposed to replace a build system.

I always thought the idea of Makefiles is great, but the language is terrible and completely unintuitive to understand and learn.

Same here. The unintuitiveness has caused three separate teams/project to remove all my Makefiles and port them back to bash scripts, rake tasks or stuff like that.

Simply because for most developers it was faster to just whip up a bash script than to modify the Makefile and understand why their change did not do what they expected it to do. Hell, i've been dabbling in Makefiles for at least 25 years and still have to look up the weird mapping expressions when for some reason there's the "nothing to be done" or "No rule to make target `xxx'".

Its only killer feature is that it's everywhere, ready to be used by any brand new developer without any work. While "Mise", Just or many of the other replacements need stuff installed and/or setup.

this is why we have mise file tasks: https://mise.jdx.dev/tasks/file-tasks.html

they're literally just bash scripts so you don't need mise to run them. I've heard several users have setups where they have people with and without mise running them.

Nice.

Nope.. it makes perfect sense if you stop misusing what it's intended for "Make file" as its purpose is to make files. They can be made using a compiler or other scripts, and as it supports files for its dependency tree.

It does not make perfect sense. It’s nearly 50 year old software and its design shows it. The basic concepts are perfectly reasonable, but the grammar is not what someone would invent today (see: Bazel).

And until recently-ish, there wasn’t a great alternative that let end users run the equivalent of `make build && make test`, but without using Make. That’s why so many people abused it so: it seemed so close to being handy and convenient. And then someone comes along and runs `touch test` and `make test` doesn’t run tests anymore because no one knew they had to label that target as PHONY.

That’s the kind of stuff that got me all-in on Just from the beginning. It “feels” kind of like Make in the nice ways, but optimized for scripting instead of for building C projects. What a breath of fresh air! And as mentioned elsewhere, for me, Mise came along right behind it and gave us do-everything tool that’s nearly ideal for the kinds of non-C projects I work on now in Rust, Python, and TypeScript.

When you’re using PHONY, you’re using the wrong tool for the job imo. (That means most people)

Just is a task runner, doesn’t do file dependencies / “derived files”

Make is the exact opposite. It’s completely based on files, and their derivatives.

Make will (well should) skip already compiled files, speeding up compilation if you’ve only changed 1 of 100000 file into ann object instead of waiting an hour, and go straight to linking.

Just is nice. But they are two different tools, that just happen to share the fact that they have some sort of dependency tree.

The tooling is 40 years old. It’s been long over due, but it’s ubiquitous.

Taskfile is so much better. mise is what actually got me to start switching everything to Taskfile instead of Makefile as mise easily handles bootstrapping Taskfile and anything else you would need.

Had been using make for simple tasks for ~8 years and just got tired of how limiting it is.

Could you explain/share quickly how you combine mise and Taskfile?

Yeah I love just, but getting the correct environment in a just task can be messy, even loading a virtualenv is annoying. I've also switched to mise for this reason

I'm really bullish on mise as a tool. It's quickly become one of my goto tools when starting a new project. Being able to have one config file to manage tools (node, python, rust, go, etc) as well as a simple makefile replacement makes it incredibly convenient. I pretty much always setup a `postinstall` hook so all someone has to do is `mise install` one of my projects and they'll get all the correct tool versions as well as having dependencies installed (like running `npm install`) automatically.

I feel it's significantly more practical than something like nix which feels like it has a steep learning curve.

There's a tool that makes the Nix way a lot more approachable: https://devenv.sh/

e.g. `languages.rust.enable = true` and you're off to the races. You can add scripts, tasks, other packages, etc

Having started with Mise, and now being primarily a Nix user — Mise still has the edge for what it does. It supports pinning exact versions of many more languages than devenv does. When devenv doesn't support pinning the version you need, it's straight back to the pain and complexity of overlays and overrides and so on.

Another Nix based alternative.. https://flox.dev/

Any hands on experience using it? I’ve looked at both this and devenv but have some level of reluctance to go with an opinionated wrapper like these as I feel like the second you need to do anything outside of the bounds of what they allow you to do you’re back in regular Nix land anyway

I've been using flox for around a year and have been pretty happy with it. It's had a few growing pains, but overall has been very reliable. I adopted it as I wanted something to install up to date development tools on top of my OS (Debian stable) and looked at flox and devenv, I went with flox as it supported zsh, which devenv didn't at the time.

I only have a few CLI/TUI programs installed with it, I try to keep it to a minimum. Just my editor, several language servers, AI tools and some other VM/container tooling. I haven't needed to break out of the happy path with it as of yet. I follow Nix progress with hopes of it eventually maturing into something better to use directly, but given the current state I prefer the wrappers at this point.

I’ve been using devenv for about 6 months now. I’ve started new projects with it and migrated old ones to use it as well. I’ve also set up my org’s repositories with it. Onboarding devs to projects is simple. All everyone needs on their local machine is git, nix, and devenv. Bonus points for using it with direnv for automatic shell activation when you enter a directory. Direnv allows for IDE integrations as well for project dependencies.

Would you be willing to share an example setup?

Sounds very interesting - I've been using just & docker (-compose) to manage my monorepo projects after a short frustrating stint with moon&proto. I like the simplicity of just, but onboarding can still be cumbersome, especially across platforms.

A mise postinstall hook?

What do you put in it?

An example from one of our monorepo's ansible directories:

    [hooks]
    postinstall = [
        "uv sync",
        "ansible-galaxy role install -r ansible/requirements.yml",
        "ansible-galaxy collection install -r ansible/requirements.yml",
    ]

Love it - great idea

In the mise.toml

https://mise.jdx.dev/hooks.html

yes! I set up a new project with mise. It makes it so much easier for new people to get started without having to do a bunch of manual steps. Awesome tool.

Not caching tasks is kind of a huge missing feature. Once you can describe a graph of tasks with dependencies, not running already clean dependencies is how you make that tractable for repeated runs even in moderate-sized monorepos.

I went looking for an issue to see if they're planning it, but the Mise repo doesn't have issues enabled? And no discussion on the README about why they don't. That doesn't inspire confidence.

If you're in a single-language npm monorepo, check out Wireit. It extends plain npm scripts to be able to have dependencies and caching (local and GitHub actions). It also has a unique service type of script for long-running tasks that lets you rebuild dependencies and no restart services.

https://github.com/google/wireit/

Mise does do local-only Make-similar task caching, if you specify sources and outputs: https://mise.jdx.dev/tasks/task-configuration.html#sources

If you specify sources but not "outputs" then mise will auto-track whether sources have been modified.

I requested the auto-track feature to speed up Docker builds a pretty long time ago, and it's been fantastic.

This is good to know! Seeing it say in the tool comparison that it doesn't support caching is a bit vague. I assumed that mean local caching too.

Ideally local and remote caching would be built on the same underlying code path.

ah I think I misinterpreted this to mean remote caching

yeah artifact caching is the obvious interpretation of caching when you're used to being compared to bazel, but the conversation was conflating "cache artifacts" and "cache should-run?" features.

> I went looking for an issue to see if they're planning it, but the Mise repo doesn't have issues enabled? And no discussion on the README about why they don't. That doesn't inspire confidence.

I'm not sure when/why the issues were turned off. That's...surprising.

There used to be an issue that said the maintainers preferred discussions over issues. I'd link to it but it's a 404 now.

I've started a discussion regarding the lack of issues: https://github.com/jdx/mise/discussions/6566

Regarding confidence: I've used the project for a couple years now. I have a ton of confidence in it and I recommend it to everyone. While preferring discussions to issues is uncommon, the release frequency and utility of mise speak for itself. Take the time to look around the discussions and/or just use it. :)

I’d argue it’s mise’s indifference to project source code and library dependencies that gives it the simplicity worth using.

There’s a couple exceptions to that boundary but in general that’s where mise stops.

Turns out caching tasks is an anti-goal:

https://mise.jdx.dev/roadmap.html#anti-goals

> Remote task caching - turbopack, moonrepo, and many others are trying to solve this (major) problem. mise's task runner will likely always just be a simple convenience around executing scripts.

That's remote caching. Local caching is still very important, and I guess it does support that.

Thanks for the clarification. I don't use any tools that do remote caching so I guess I just glossed over that qualification. :o/

What's a remote task in this context?

You are asking mise to become a build system like bazel. I suppose it already is one, in a sense. Caching is a useful feature but mise needs to guard against increasing complexity. Perhaps it could integrate with builds tools.

Speaking of task caching, this is what Mint/RWX does really great, just as you described - graph of dependencies and running only what has changed since the runs. Really helps speed up CI/CD tasks and lower the costs.

Mise seems pretty cool, but the thing that makes me reluctant to get on board now (current asdf user) is that it seems to want to manage too much. Especially with regard to using PATH munging.

I've had substantial frustration with multiple tools all trying to redo my PATH for me, usually to make themselves the first thing. It's to the point where I decided to give up and hard-code my PATH in my .zprofile and get rid of all of the various tools' init scripts so that I at least can clearly see and control which things are in which order and not having a bunch of scripts trying to rewrite it all the time all with slightly different algorithms.

Maybe it would work if mise could manage all "tools" (various programming languages) as well as "tools" (actual CLI applications written in one of the languages and usually installed with that languages manager, like `cargo install`, `go install`, `uv tool install`, etc), though then it seems like it might be a pain to switch over to.

> I've had substantial frustration with multiple tools all trying to redo my PATH for me, usually to make themselves the first thing.

it doesn't do this, you can even use shims with mise if you really want to

> Maybe it would work if mise could manage all "tools" (various programming languages) as well as "tools" (actual CLI applications written in one of the languages and usually installed with that languages manager, like `cargo install`, `go install`, `uv tool install`, etc), though then it seems like it might be a pain to switch over to.

it does do this

can't remember why I switched from asdf to mise, but I've had no problems with it in the last few years

Startup time, maybe? I switched from pyenv to mise because it was adding significant time to my shell startup.

yeah, very likely!

Mise is the best.

If you are a stickler about automation, easily repeatable system state, and being able to bootstrap new projects without having to eff around with the crap show of Ruby/Python/Node envs and how every person likes to use different tools for setting those up, or even just making it simple to have repeatable envs for go and rust, its great. Especially because you can do it without getting Docker/containerd involved.

Works great for getting a basic repeatable CI type build up and running without having to get CI or a big build system involved. Those are the right tools in the right situations, but for small teams or personal projects, I'm not going through the hassle and JVM dependencies of Bazel, Gradle, etc.

I also use it to manage my local system tools in my dotfiles (in combination with chezmoi).

>having to eff around with the crap show of Ruby/Python/Node envs and how every person likes to use different tools for setting those up

This was the problem I wanted to solve, and I ended up on nix+direnv (and am considering devenv) because nix, due to the existence of nixos, packages all the tools already! Does Mise support zig? or nim? or crystal? Nix does! And Nix will continue to keep up to date with all the tools, whereas things like asdf and mise - since they're specialized and not the basis of a full distro - are less likely to do so.

If you want to run al these possible supplychain attacks onto your host machine, be my guest.

Kind of interesting seeing mise grow and grow. Others have noted they encountered it first as a direnv replacement. At my last job it was an asdf tool-installer replacement. It's also a task and now mono-repo task runner.

It feels a little fragile to me to try to tackle so many concerns: if folks start relying on mise for more capabilities and one of them falls short, isn't as good as it could be, that could be a big hurt. There's definitely a nice conceptual win to having an all in one tool, but scoping up ambition feels risky.

Especially with task running, it feels like there's really so many very specific expert concerns that come into play. Being able to have a task graph & understanding the minimum work needed, being able to run only downstream tasks is a pretty important need, and that really gets into programming language specific views of what's happening. The idea of having something generic & so all is tempting but it feels impossible to get satisfactory results here.

Beyond Mise specifically, it's just interesting seeing the continuum between specific & multi-purpose tool, and seeing how software tends to scope itself up.

I'd counter that I actively don't want those more powerful features. Like, I get why anyone would want them, but right now Mise is "knowable". I can sit down with its doc site and figure out any of its features without building a strong mental model of their underlying implementation. And that also means my coworkers aren't as likely to abuse and twist it into the kinds of things people have used tools like Make for.

I would vastly rather have Mise shell out to Make etc for more complex DAG stuff. Those tools already exist and are good at their own specialties. Mise doesn't need to reinvent everything.

But I do think the new monorepo tasks are very on-brand for it. They don't seem so much as to add deep functionality as to provide a convention for finding and running other Mise files in a repo.

> But I do think the new monorepo tasks are very on-brand for it. They don't seem so much as to add deep functionality as to provide a convention for finding and running other Mise files in a repo.

yeah, "fancy bash scripts" is a good way to think about tasks

And that's the way I like it. heart_emoji.gif

I'm really excited about this. I think it blends the both worlds of simple task runners like just/taskfile while also having a lot of the power of tools like bazel/buck2. Excited to hear about what people build!

I don't know, I'm torn about it.

I use mise and mostly like it. It has simplified my workflow for managing environments. But I don't need a task runner. `Make` and `just` already fulfill that purpose for me. I haven't used them in a monorepo, but both support importing and extending task/recipe files, so presumably it's possible to set them up appropriately. Maybe the UX wouldn't be as polished as a tool built for that use case, but I like my tools to "do one thing well". mise already does quite a lot as an environment manager, and I'd prefer it to remain focused on those problems.

Ah, you're the author. Thanks for all your work!

Nice work @jdxcode, this looks great.

Is there any functionality in this release that might help with or be useful in features for sharing Mise config/tasks _across_ repos?

And do you have any thoughts on that idea in general?

https://github.com/jdx/mise/discussions/4562

I don't, sorry

No worries, thanks!

Mise has become almost indispensable for me within just a few months, I've rebuilt so much of our tooling around it. If anyone else finds it as integral to their work I'd like to encourage them to also sponsor it.

For me, because I jump from project to project, different versions and languages, is just perfect to use the same mise commands, and I know it's going to work.

Also I like having a global portable ~/.config/mise/config.toml file.

What I'm not sure yet is how to mix it with brew on Mac OS, so far what I do is, everything I can install with mise, I do, so I know it will work in linux as well, and everything else with brew.

There are exceptions like postgres, which seems available in the registry (asdf:mise-plugins/mise-postgres) but then you need to do:

brew install gcc readline zlib curl ossp-uuid icu4c pkg-config

My rule is, everything that doesn't have brew dependencies and is in mise registry or plugins, I install it from there, everything else from brew. But I'm curious, what's your approach ?

The creator of mise has written about it [1] but I don't think he switches from mac to linux:

> I tend to basically just use core plugins. I like mise for managing things where I really care about the major version (like node). If it's something like shfmt or jq I don't really care about the version. I just want the latest and for me, I find brew to be better suited to that purpose.

- [1] https://mise.jdx.dev/how-i-use-mise.html

I follow what you've quoted at the end of your post. I only use mise for things I need multiple versions of.

For quite some time, I have gathered this set of Rust CLI tasks that are exactly the same. I have used them as template generators for cargo-generate. This became a problem recently when I was writing a monorepo that had mixed projects (Rust server, Svelte Frontend, and Terraform deployment). This comes at just the right time for me to utilize this without going insane.

Also, I had a not-so-great experience with other builders/managers, including lerna so I love this.

@jdxcode, how long before I can replace Emacs with mise?

I hope never! scope is big enough!

Mise is a hard sell for me when I can have pure Nix-shells. However, I can see this gaining wider adoption since it's learning curve is so much lower than Nix.

I tried nix-darwin for a year, eventually declared nix bankruptcy, and settled on mise.

mise does 90% of what I need, but at only 1% of the hassle.

I like the idea of nix, and the future of building software is clearly something like it... I'm just not sure it'll be nix itself.

I've seen several Mac users have the same experience: going all-in on nix-darwin and then getting frustrated. But nix-darwin is one of the worst ways of getting into Nix, because its goal is to make your whole macOS system configurable with Nix, but macOS is a moving target and (unlike Linux) not built to be modular at all. I know people put a lot of hard work into nix-darwin, but it's simply not the main focus of Nix as a whole and sadly it might not ever become a seamless experience. (I'm not a mac user so not keeping up, but I do see colleagues trying it out from time to time.)

The solution here is: use Nix but don't use nix-darwin (at least not until you're generally comfortable with Nix for package management and dev shells). You do NOT have to use nix-darwin on Mac to reap 80% of the benefits of Nix (especially in a team setting).

After dropping nix-darwin, I think almost everyone will find that it's very easy to use Nix for sharing project setups with bespoke tooling. I just had a new team member onboard, knowing nothing about Nix, in a day or less, with several different languages and unusual tools.

> After dropping nix-darwin, I think almost everyone will find that it's very easy to use Nix for sharing project setups with bespoke tooling

Ahh, but I tried that too. I originally decided to play with nix-darwin because I was on a contract that used nix in their repos to ease onboarding of academic collaborators.

In practice, it was complicated enough that most of us ended up relying on the 2 nix experts to make any real changes, and when they left, the nix configs stagnated.

It might be the case that nix-darwin, and our particular python/ML repos, were "hard mode" for nix, but I truly think I gave it a fair shake.

If nix requires a lot of effort to do anything off the beaten path, it's just not the tool for me.

To be clear, I don't try to Nix-everything. I just use it to 1) install a bunch of CLI tools to my nix-env, and 2) dev-shells. That's pretty much it, though. Even that is a huge boon. Even so, I'm keeping an eye on mise, for sure.

If you think of it more of in the context of making it easy for people other than you and your bespoke machine to bootstrap a project, that's where it really shines. The toml config is very simple for people to understand.

I use it because I want people to be able to get projects up and running quickly without having to comb through an outdated README, trying to deal with all of the different ways people like to install and use non-compiled languages, etc. Managing anything Node/Ruby/Python is all annoying.

If you want to get a single entry point into your repo's task, also consider my tool: dela[0]. It scans a variety of task file definitions like pyproject.toml, package.json, makefile, etc and makes them available on the cli via the bare name of the task. It has been very convenient for me so far on diverse repos, and the best part is that I didn't have to convince anyone else working on the repos to adjust the repos structure.

Dela doesn't currently support mise as a source of tasks, but I will happily implement it if there is demand. Currently [1] I saw mise use on 94 out of 100,000 most starred github repos.

Thank you for allowing this moment of self promotion.

[0] https://github.com/aleyan/dela

[1] https://aleyan.com/blog/2025-task-runners-census/#most-used-...

Sounds great but does it support listing all tasks?

Whenever I enter a repository for a node project the first thing I do is "npm run" to list the scripts. When I enter a repository with a Makefile I look at it. If I see make targets where both the target and dependencies are variables I exit the repository again real quick though.

How does this compare to moon?

https://github.com/moonrepo/moon

I’m not super familiar with moon, but I think it’d be fair to say mise started out solving the tool problem where moon solved the build problem first. I’d expect both to be more fleshed out than the other in both departments.

You could probably use mise tools for moon builds, or proto with mise tasks too if you wanted to.

Can someone with both Bazel and mise experience comment on whether mise fulfils its promise of being a "sweet spot" between Bazel and anarchy?

I've used Bazel a lot and contributed to it, but don't feel like it's adoptable by engineering teams <100 in size. mise might be an option though.

I've used bazel for about 10 years, all in small orgs. Right now, single digit team.

I don't think there exists a better solution for a project mixing Java and C/C++ than Bazel. The new module system for bazel has matured a lot. As an example, it's trivial to add boringssl and access it from Java.

This is fair. mise (by design) does nothing to help with that sort of thing. It's also definitely designed for languages outside C/C++, and to a lesser degree Java.

mise tasks are basically just fancy bash scripts though, so I could totally see a setup that uses mise tasks/tools for node/js/ruby and dispatches to other tools for building Java and C/C++.

> Taskfile and Just are fantastic for single-project task automation. They're lightweight and easy to set up, but they weren't designed with monorepos in mind. While you can have multiple Taskfiles/Justfiles in a repo, they don't provide unified task discovery, cross-project wildcards, or automatic tool/environment inheritance across projects.

Not true, Taskfile supports inheritance of both itself and dotenvs. The main selling point of mice seems to be tamed multilang mixing. In case of pure-golang monorepos, mice seems like a lot of extra bloat.

For less developed / standardized platforms like py/node, it may come in handy. Of course it had to be written in rust…

IMHO the document's introduction should explain why this double-slash // syntax is being used. It may be obvious to some readers, but not to me.

Is it a well known convention for a monorepo root-relative path?

I was a bit slow to hop on mise because it took me while understand it (Likely because I entered thinking of it as a direnv replacement with more features).

It especially makes life behind corporate barbed wires easier for me (YMMV).

Nice to hear this input... My first glance, I didn't really notice that Windows was supported, and it looks like there's support for dotnet as well... so may give it a try in the near future.

My work env is pretty locked down as well... I've mostly relied on just using Deno+TS for shell scripts since it's relatively consistent for me across work and personal environments and the tooling can run from a user install. Though not using it to manage my tooling itself for work projects.

As someone also behind corporate barbed wire and responsible for some build tools, I’m interested! What in particular makes life easier for you?

I have replaced manual (and tedious) download binary from Github releases and install workflows. Also switched from pyenv to mise for Python which I feel is an improvement in the experience.

I recently moved from just to mise. Just is great but it is only a command runner and I needed mise other features and I'm glad I made the switch. I just wish docs would improve a little in structure and explanation of usecases/history while drawing comparison with other things like nix,docker etc as a newbie it helps to know the why like:

"we often need to run programs as side effect" => "scripts" => "task runner" => "make/just" => "mise"

and also why not docker or nix pros/cons etc

I think their comparison table is a bit incorrect:

You can totally run non-JS/TS monorepos with turborepo. (But you need an additional package.json per module.)

(Note: I'm not saying it's better or worse than this.)

This is awesome! Just the other day I was thinking it would be nice if mise had something like this.

Mise has been great for me. What I like most is the ability to install tools globally with the npm, go and cargo backends, e.g. "mise use -g npm:prettier".

It's a simple thing but before, when I had to use something like nvm, I always had to remember which of the node versions I had installed global packages into.

I did recently have an issue where installing the newest node version actually installed the second newest one but that's a small thing.

I'm a bit late to this thread, but also wanted to express my thanks to Jeff for mise. I have a lot of different projects in my ~ directory in various languages and with various task runners. Migrating dependency management and wrapping tasks in mise's task runner has removed so much cognitive overhead getting spun back up on projects I haven't touched in a while. Great work!

glad to hear! I got more flak than praise when I launched tasks 2 years ago since people didn't want mise to get too complex but I'm glad I stuck with my guns and pushed it anyways. I thought bringing tasks and tools together made a lot of sense and I'm glad you're seeing the value of it

I love mise so much and use it at $DAYJOB to manage a multi-service polyglot monorepo. Can't wait to try this.

(no offense, I'm probably missing something)

Isn't running tasks in various folders kinda low hanging fruit for monorepo tasks? I've wanted a language/CI agnostic `monorepo-build-tool` build tool for a while, and getting something that allows for `monorepo-build-tool run-affected -- script/test` was one prompt to an LLM.

The bigger problem is caching and determining which projects need to be run when calling `run-affected`.

i will just add another comment appreciating mise.

i even added some mise config lines to my global gitignore because i often use it in projects by others that don't set up mise config.

Does mise overlap with uv for python?

To some extent, yes, but you can have mise defer to uv for the python side. I have mise using uv, npm, clojure, and java, and it defers to all their packaging systems.

But it also allows me to control their versions in one spot, and present a unified task interface and dependency setup. E.g., I can make a testing task that runs playwright, but will depend on a python/java build task first.

Mise shines in polyglot systems.

I’m just now learning about mise tasks, this is amazing!