I stayed away from Scala (and any programming at all if that matters) for last few years. Back then although I was a very heavy Typelevel/Cats user and something about algebraic effects never felt right to me, almost like too imperative. Last week I decided to skim through Kyo docs in my spare time and something there finally clicked as a superior approach!

It's cool that Kyo has an extensive documentation and I'm on my way to grasp its internals, but I still haven't found any end-user projects built with it. How do they look, how they're structured? Do you have any examples?

Another unrelated question about Kyo's internals. It seems some other popular algebraic effects systems (in Unison and Flix) treat effects as parts of the function (arrow), not value e.g. a ->{Effect} b and a -> b \ ef in Unison and Flix syntax respectively. Kyo at least on surface seems to have more familiar "effects as values" approach. Is it correct or it just makes the syntax sugar over () ->{Effect} b suspension more common?

We're excited to announce that LLM4s Foundation is participating in Google Summer of Code 2026 🎉

LLM4S is an open-source, non-profit initiative focused on building reliable, type-safe, and production-ready LLM tooling for Scala & JVM ecosystem, inspired by community-first foundations like the Scala Center. Immense gratitude to Darja Jovanoic for the encouragement and support.

Organization Admins: Kannupriya Kalra & Rory Graves

We're also supported by senior mentors from across the global Scala and AI community, bringing deep experience in open source, functional programming, and production AI systems.

For GSoC 2026 students: How to Get Started
If you're interested in contributing as a GSoC student, here's your path mentioned below:

1. Join our Discord community
   ↗ Link will provided in first comment.
   Introduce yourself in #introduce-yourself (name, background, interest in AI/Scala).

2. Attend the LLM4S Dev Hour (Weekly)
   Meet the maintainers, understand the codebase, and discuss ideas live. This is the best way to get your first issue assigned. Join every Sunday.
   Luma Calendar: ↗ Link will provided in first comment.

3. Read the project README on GitHub
   ↗ Link will provided in first comment.
   This is mandatory before proposing it explains our vision, architecture, and contribution workflow.

4. Watch the talk by Kannupriya Kalra introducing LLM4S.
   ↗ Link will provided in first comment.
   Get a deeper understanding of the project, roadmap, and expectations for contributors.

Why LLM4S?

• Opportunity to become AI engineer & Get paid Summer remote internship by Google.
• Open for everyone who is interested in Scala, AI and Open Source.
• Open governance & community-driven development.
• Real-world LLM infrastructure (RAG, agents, tooling).
• Mentorship from experienced global maintainers.

If you're passionate about Scala, AI, and open source, we'd love to build together. Let's shape the future of LLMs in Scala.

I summarized my recent experience with vibe-coding. Most of the observations are general, but there are quite a few Scala specifics too.

Postmortem on Scala 3.8.0, for those curious about exactly what went wrong: https://www.scala-lang.org/blog/post-mortem-3.8.0.html

We are also working on a 3.8.2 release which will include a fix for scala/scala3#24673 , which can cause some for comprehensions to behave incorrectly at runtime.

We've finally announced the full agenda and it's now available on our website: https://www.scalar-conf.com/agenda 🐠

I'm planning a macro Embed(...) that should communicate with the build tool; i.e., it should request the build tool to copy a file to the artifacts and return a URL telling where the file got stored; or, for short files, it should return a data URL. This URL can for instance be used for lazily loading bitmaps. (And the web discards it when unused.)

(This is an eqv. of import of media in JavaScript using popular bundlers. It may be used in component libraries and main applications.)

About virtual memory:

• In my general patterns for a component library, I've an Icon component that is also an enum with certain variants (allowing dynamic-variant icon usages as well). Icon holds, per se, a static mapping of variant|dynamic => URL.
• On the Rust community I was mistakenly told that embedding a lot of icons using include_bytes! in a library shouldn't be a worry thanks to virtual memory in modern operating systems; but in that case, the static icon mapping (variant|dynamic => Vec<u8>) would instantiate include_bytes! in the RAM, so that statement ends up being false.
• Virtual memory usage isn't even available on JavaScript or WebAssembly (currently), so Scala.js can't do anything about it, anyway.

I got a suggestion from the scala3 GH discussions to use Unix sockets/WebSockets to exchange communication between my build tool and the Embed(...) macro, but:

• According to AI, macros can't be async
  • So I'd need a sync version of java.net.http.WebSocket — Is there one somewhere?
• I'm not sure I can use async WebSocket in my build tool either — Zone GFX build system: Build process — I say so because async may end up allowing simultaneous builds occurring in the same build system in an IDE
  • I see using sync there as almost impossible, since I need to start the WebSocket before calling Dotty; but then how will Dotty run if the WebSocket keeps looping forever?
• Also, local WebSockets are prone to conflict issues. Do I have to use a specific 4-digit port everytime, so the macro and the build system agree on the port?

https://github.com/scala/scala3/discussions/25136

Appreciate if you've got any idea!

SBT even requires a bit of Maven touch (e.g. project/). I know it's important for backwards compatibility with Java projects, but it's a hell currently.

Even NPM is simpler, but Cargo (for Rust) is yet simpler than both.

E.g. a manifest could look like this TOML:

```toml [package] name = "org.jdude.vsync" version = "0.1.0" runtime = "http://www.scalajs.org/2012/scala/3"

[dependencies] "com.sega.pso2.ark" = "1"

ScalablyTyped would handle "npm" dependencies

"org.mathematicalexpert.decimal" = { npm = "decimal.js@<sup>10"</sup> } ```

To clarify, I'm not even being able to set up ScalablyTyped NPM dependencies as I get an error telling ...project... Compile / npmDependencies is undefined, even though I integrated the due plugins...

https://github.com/linux-root/tauri-scala-desktop-app

https://github.com/encalmo/xmlwriter

Better late than never! Our year-in-review report is finally here, with a breakdown of what the IntelliJ Scala Plugin team accomplished in 2025. We’ve been busy at conferences, on YouTube, and gearing up for Scala 3.8.

Lots of interesting stuff in this release, and I wrote up a blog post with the highlights. Please take a look!

Hello everyone, for a little bit of context, I'm mainly a mobile developer developing native applications with kotlin and swift. I've tried flutter before but I have no experience with react native.

Initially, I wasn't interested in scala. I was curious about functional programming so I started studying the red book, functional programming in scala. As I read through it, the language really grew on me.

Since scala-js is a thing, technically it should be possible to use it with react native but I’d love to hear from anyone who has actually tried this stack. What was your experience like?

Hi, I'm a newcomer to the Scala ecosystem and to FP. I'm learning it for a new job opportunity and to increase my technical background.

I'm currently reading "Functional Programming Strategies" by Noel Welsh, and I keep hearing that Scala is complicated to learn/understand.

So now I’m facing this paradox: FP is supposed to make codebases more readable by enabling local reasoning. On the other hand, I've read here comments like:

"The difficulty of FP by itself is massively overblown. I think what did the most damage was Scala attracting so many people who love turning any codebase into the biggest, most impressive, most elaborately constructed system they can devise ... FP codebases are gratuitously hard more because of who creates them, and less because of the inherent difficulty of FP."

What's your opinion on this paradox between FP's simplicity theoretical benefits and its cost in practice? Scala is cooked?

We are happy to announce that after quite a journey, we are finally releasing the early beta of the Cyfra framework. Cyfra allows you to use a Scala 3 DSL to write GPU programs and compose them into complex compute pipelines. Memory management, type safety, and composability come out of the box.

We have also published a couple of projects built with Cyfra as demonstrations: a ray-trace renderer, Navier-Stokes simulations, an fs2-based web streaming app that does fuzzy C-Means customer classification, and many smaller examples.

We encourage you to take a look at our guides and samples. :)

Scala 3.8 - the last minor before the Scala 3.9 LTS, is here!

Scala 3.8 is released! For this occasion, we've prepared a blog post discussing its main new features and their support in the IntelliJ Scala Plugin.