sbt-jib VS ZIO

There's also https://github.com/sbt-jib/sbt-jib/ if you're having trouble with sbt-native-packager

I have been using https://github.com/sbt-jib/sbt-jib for some time now, it makes building images very easy.

You should use sbt-jib. (You shouldn't use sbt-native-packager either, it doesn't work well in this regard: [1], [2].)

[2026-03-18T16:00:01.140Z] Bounty Monitor starting... [2026-03-18T16:00:01.143Z] Fetching Algora bounties... [2026-03-18T16:00:01.222Z] Fetching GitHub bounty issues (last 2 hours)... [2026-03-18T16:00:02.089Z] Found 0 GitHub bounties >= $200 in TS/JS/Python [2026-03-18T16:00:03.137Z] Found 11 Algora bounties >= $200 RESULTS: 11 bounties found [SEEN] $5000 — Algora Bounty URL: https://github.com/zio/zio/issues/9356 [SEEN] $4000 — Algora Bounty URL: https://github.com/archestra-ai/archestra/issues/1301 [NEW] $2500 — Algora Bounty URL: https://github.com/golemcloud/golem-cli/issues/275

> If you want to read more, I’d recommend starting with the Effekt and Koka language tours

Instead of exploring a research language that nobody uses you could try a mature effects system for a semi-popular language. I think Zio is great and runs on the JVM and ScalaJS. https://zio.dev/

That's quite an unfortunate name given there's already a famous async framework named ZIO for Scala

https://github.com/zio/zio

I use ZIO (https://zio.dev) and nothing really like it exists on any platform.

You can wrap any computation in a single ZIO object e.g. normal, callback, future, promise etc. Which you can then chain together in different ways e.g. run them in parallel, sequentially, race them against each other and kill the loser, scheduling in elaborate ways etc.

And it will execute this either using normal or virtual threads i.e. fibers without locks so it’s extremely fast.

But the incredible part is that it does all of this whilst seamlessly handling every type of error. Which if you’ve ever written complex concurrent code is extremely hard to get right.

I was super pumped when the Zio creator had a hand in creating this State-Machine-That-Can’t-Crash as a Service, called Golem. I was further excited because they had support for Grain, an OCAML style FP soundly typed language. I could just never find the time/inspiration to play as I still feel trapped in the “all things are AWS” vortex. Yes, I’ve played with & used CloudFlare in production, but… as a AWS Step Functions fan, this seemed like a cool idea. One of these weekends I’ll try again with TypeScript since Grain appears to be no longer an option.

scala has 2 healthy and pretty complete lib ecosystems : check out typelevel and ZIO. Both are FP oriented, which might not be your cup of tea at first glance but I would encourage you to try em out ! Softest introduction would be to start with the typelevel cats library and build up from there. The excellent Scala with Cats will ease you softly into an FP mindset. It's a bit dated and for scala 2 only but translating to Scala 3 is a very good exercise if you feel so inclined !

Last but not least, Scala is currently the language with one of the best effect systems in my opinion (https://zio.dev/). Kotlin for example has copied the approach with https://arrow-kt.io/ which I think is great actually. But when comparing Scala and Kotlin here, Scala wins by a large margin, it is a completely different world. It's like building a highly concurrent system in Erlang vs C.

Of course, if you don't want to learn things like union types, traits/typeclasses and effects (similar to async/await but more powerful) you will be annoyed by Scala. But once you learned them, you can never go back.

ZIO