Two days ago, I gave a presentation on parser combinators, and it was a great success! However, due to issues I encountered in #beginners > Why is my parser causing a stack overflow?, I had to switch the talk from Roc to Elm. During the Q&A, I noticed some confusion about currying, and I believe the presentation would have been even better if I had used Roc.
That said, there’s interest in delivering the talk with Roc, though I’m not sure when that will be possible given the current challenges. Although @Brendan Hansknecht kindly found a workaround, I’d prefer to wait until the issue is fully resolved rather than implement a temporary fix.
My question is: Is there an ETA on when the new compiler will be released? No rush at all—I just want to manage the expectations of the Roc enthusiasts from my recent presentation.
Short answer, no ETA yet
We'd love to give a date, but there's enough changes that we're making architecturally at the same time as we are rewriting the whole thing to make it a hard estimate
We'd like to have v0.1.0 released this year, which should be possible, but it's hard to make a guarantee
That all said, we'll definitely have a "fully-working compiler" that you can run yourself in the next few months, but it won't have all the features yet, just a basic set of features working end-to-end
Said version would be compiled from source, which isn't that hard, but still, it won't be "published" per se
Yeah, it's hard to estimate. Everyone working on the new compiler is volunteering their time around personal commitments and work.
We're pretty excited about it, and things are happening really fast, but I don't know how to estimate how far away a working compiler is yet.
Im personally really keen to build an online playground, and exploring the embedded use cases for roc. I think that will be much nicer with our new designs. We might even have something experimental sooner because that's mostly using the dev interpreter and not the full llvm build pipeline.
That's completely fair. Thanks for the update. Could you clarify what counts as "essential features"? My parser is pretty basic aside from opaque types, but if I'm not mistaken, the current implementation for opaque types won't be included in the new compiler.
I'm willing to help out wherever possible, though I'm not quite sure where to get started. Please let me know if there's any way I can contribute. :smile:
There's lots of stuff you can help out with!
But to answer your question, "essential features" that will get us on the ground and running would be the ability to write multiple modules which include functions and strings, and that's enough to show that everything works together
We'll be starting with the new interpreter which picks things up post typechecking
Meaning the whole second half of the compiler (the build phase) won't block us from getting code running
Feel free to DM me or any of the contributors if you (or anyone reading this) wants to discuss what you could contribute
Kevin Hovsäter has marked this topic as resolved.
As a note, due to building an interpreter that skips most of the optimization passes and many "hard parts" of implementing roc. I think it is possible that we may have a fully functional interpreted roc quite a while before we have a fully functional optimized roc.
I agree with this, we are probably 2 weeks away from a functionally complete parser, and I know a lot of progress has been made in Can. And with Brendan working on the interpreter that will probably go pretty fast as well (which is great for us having some form of E2E testing in place)
Y'all are impressive. :clap:
I'm not sure how it would do for your use case, but Gleam is sometimes worth a look as a stop gap especially given the new Roc syntax direction
I've been messing around with Nim, which is interesting enough (albeit no Roc of course). I like Gleam (and Elixir etc.) but for some tooling I'm trying to write, I'm unwilling to pay the VM startup cost, and am looking for small, tight binaries.
Fortunately, AI-assisted coding gets you up to speed really quick with new languages, and your hard-earned existing general-purpose computing knowledge helps even more in that context (for example, if you force them to use TDD, they write better code! Just like humans! But also just like humans, you have to keep reminding them... lol)
Last updated: Jul 06 2025 at 12:14 UTC