This is exactly the language I've been yearning for - the exact motivations and intersection of features that would be the sweet spot for me.
Kotlin without the Java baggage.
Rust without the garbage collector and async bifurcation.
Go with a modern type system.
Swift but with green threads and a linux community.
Haskell without the hair shirt.
Elixir with a full type system and native performance.
But yes there are some flags others have mentioned, I won't repeat them. "goroutines" ?
Even on the off chance this project is not entirely vibe coded how could it ever build an ecosystem? How can any new language? All the libraries would be suspect for the same reason this repo is. The agents won't know anything about it, no one will believe it can get momentum so it won't.
If you are interested in Gossamer, you may also be interested in Lis, which is Rust flavored and compiles to go: https://github.com/ivov/lisette
From their readme:
Safe and expressive:
- Hindley-Milner type system
- Algebraic data types, pattern matching
- Expression-oriented, immutable by default
- Rust-like syntax plus |> operator and try blocks
- Go-style interfaces, channels, goroutines
Quietly practical:
- Interop with Go ecosystem (WIP)
- Linter, formatter, 250+ diagnostics
- Fast incremental compiler, readable Go
- LSP for VSCode, Neovim, Zed, Helix, GoLand
I would also like to toss my project into the ring, which also allows mixing most real-world Rust & Go packages together, on runtime & syntax compatible level. https://github.com/deepai-org/omnivm
Pardon the sloppy readme - it actually does work :)
Somewhat with you on this. I got slightly excited for a brief moment, but then the site starts to scream "an LLM threw this together super quickly" which doesn't spark joy at all.
I then started digging into the code examples and quickly determined that nothing about this project is for me, even as a fan of Rust and some of its influences it has on recent languages. That web routing example is absolutely gross to my eye, for example.
Different strokes for different folks - my own thoughts on language design (I'm hacking on one in private over the past several years, maybe one day it'll be shareable) would probably make some folks have a similar reaction, despite taking a wildly different approach than here. But it does suck to see Yet Another Vibe Looking Site hosting a language that feels like Yet Another Flavor Of Similar Stuff. Really looking forward to a language that wildly shakes things up in a usable way, and has a lot of care put into the DX... this one did not check that box for me.
Looks like we may be going to go back to the geocities days of primitive websites. I use still use hugo to generate my personal site automatically from markdown upon PR approval.
It's only 2 months old. Clearly vibe coded. Still, kind of crazy what you can vibe code now.
Also the actual language design seems quite nice. I'd love something like this that was embeddable (and not vibe coded). There are basically no good easily embeddable languages. Everyone used Lua but it sucks.
Glad to see more languages adopt true goroutines [edit: lightweight threads or fibers] with M:N scheduling. Surprised more haven't. Among compiled language I'm only aware of Go and Crystal off the top of my mind.
Haskell does too. And it predates Go by a large margin, such that calling it goroutine is weird. And within Google, the C++ implementation fiber also predated goroutines. It really shows that this is more of a library feature rather than a language feature.
Gossamer has a cycle collector and eager reference counting. Good luck dropping the last reference to a 10,000-node graph, especially if cyclic. That means it doesn't have "pause free" memory. If you want pause freedom, go use ZGC or another modern GC on a modern VM.
I just can't take seriously this spate of languages that ignore the past 30 years of research into automatic memory management. We have multiple open-source pauseless miracles GCs right there before our eyes, yet it's the trendy thing in language design to foist memory management on users.
You don't even have to use a big VM if you want good GC. Go use MPS. Lots of options out there, even if you want to implement your own VM.
The one plus I'll give reference counting is it still takes the cake for interoperability with C. Which is only important if you need good interoperability, but when you do, tracing GCs don't play nice.
> We have multiple open-source pauseleses miracles right there before our eyes
Is this meaningfully true in a practical sense? I've been writing code with soft real-time requirements and I don't think your notion of "pauseless" suffices. And if these miracles are open-source and right before our eyes, why do languages like Crystal and D still use Boehm?
You seem to have a very low opinion of other people. If these miraculous collectors are so generally applicable, why are very smart people putting effort into things like Perseus?
Smart, honest people can have sincere and earnest disagreements. I believe the manual-memory-management people are mistaken. That's not to say they're stupid: it means I believe they're going down the wrong path, as smart people have done since time immemorial. I wish them all the best. That said, I must wonder what other innovations they reject if they insist that GC is unacceptable.
> ZGC performs all expensive work concurrently, without stopping the execution of application threads for more than a millisecond. It is suitable for applications which require low latency. Pause times are independent of the heap size that is being used. ZGC works well with heap sizes from a few hundred megabytes to 16TB.
V8's Orinoco is also pretty good now. It's improved a lot over the past decade and is now mostly-parallel. (A decade is about how long one of these things takes: high-performance GC is hard.)
I'm also a fan of MPS: it's a big of dark horse because it's more a GC construction kit than a ready-to-go GC, but it's fast and flexible, and I'd start with it any day over Boehm if I were making a VM from scratch.
Game GCs are interesting because you know that the execution is structured like this and you know how much time you have left before you have to switch back to application code for the next frame/time step. There's interesting optimizations you can make around this and could almost completely avoid user-observable GC pauses.
Various GCs can go faster now too. JEP 376 talks about hundreds-of-microsecond work done in pause now that GC no longer has to scan the whole stack.
That said: 1ms? 1ms is getting into the sorts of latency the OS and hardware impose on your program no matter what it does. For example, on x86, a SMI can take 300us, or 1000us if you're unlucky. I've seen softirqs for shitty wifi chips take a hundred milliseconds! And God help you if you take a hard page fault:
You're worried about 1ms latencies, right? So you're mlock()ing all memory? Running RT threads pinned to cores? Carefully using PI and static priorities to avoid inversions? Avoiding blocking IO everywhere, not even for graphics page-flipping? Managing thermal headroom to avoid involuntary clock collapses? And it should go without saying, but I have to ask: you're running a PREEMPT_RT kernel, right?
No? You're not doing any of these things? Then why are you worried about 1ms in GC?
If I were writing this language, I'd probably just compile it to Go, although that means Rust extensions would either incur cgo costs or have to be replaced with Go extensions.
IDK what's the fuss. m:n scheduled by io is .. 2000s-era. The implementation was so obvious in like 2005, that even I patched then Python 2.6 in, so we at my then company could get rid of Twisted.
Also let you remind that M:N scheduling was the FreeBSD's pthread implementation for quite a bit too long. No, it didn't play well with MySQL at the time.
Kotlin without the Java baggage. Rust without the garbage collector and async bifurcation. Go with a modern type system. Swift but with green threads and a linux community. Haskell without the hair shirt. Elixir with a full type system and native performance.
But yes there are some flags others have mentioned, I won't repeat them. "goroutines" ?
Even on the off chance this project is not entirely vibe coded how could it ever build an ecosystem? How can any new language? All the libraries would be suspect for the same reason this repo is. The agents won't know anything about it, no one will believe it can get momentum so it won't.
From their readme:
Pardon the sloppy readme - it actually does work :)
```python names = sorted({name.lower() for name in users if name}) ```
vs.
```gossamer let names = users |> iter::filter(|n: String| n.len() > 0) |> iter::map(|n: String| n.to_lower()) |> iter::sort_by_key(|n: String| n.len()) ```
Python is sorting a set (unique values only), but I'm not seeing a unique or set approach for gossamer.
Now, it's just a neutral or perhaps even very slightly negative signal (especially the em-dash in the very first line of the page).
Anyone able to tell me if this is a project actually worth paying attention to, or just another raindrop in the current monsoon of slop?
I then started digging into the code examples and quickly determined that nothing about this project is for me, even as a fan of Rust and some of its influences it has on recent languages. That web routing example is absolutely gross to my eye, for example.
Different strokes for different folks - my own thoughts on language design (I'm hacking on one in private over the past several years, maybe one day it'll be shareable) would probably make some folks have a similar reaction, despite taking a wildly different approach than here. But it does suck to see Yet Another Vibe Looking Site hosting a language that feels like Yet Another Flavor Of Similar Stuff. Really looking forward to a language that wildly shakes things up in a usable way, and has a lot of care put into the DX... this one did not check that box for me.
It's decent design, but not a useful quality signal.
Also the actual language design seems quite nice. I'd love something like this that was embeddable (and not vibe coded). There are basically no good easily embeddable languages. Everyone used Lua but it sucks.
I just can't take seriously this spate of languages that ignore the past 30 years of research into automatic memory management. We have multiple open-source pauseless miracles GCs right there before our eyes, yet it's the trendy thing in language design to foist memory management on users.
You don't even have to use a big VM if you want good GC. Go use MPS. Lots of options out there, even if you want to implement your own VM.
Is this meaningfully true in a practical sense? I've been writing code with soft real-time requirements and I don't think your notion of "pauseless" suffices. And if these miracles are open-source and right before our eyes, why do languages like Crystal and D still use Boehm?
Of course, this assumes you're in a preemptive environment with access to other threads, etc.
Can you share some links/references?
https://wiki.openjdk.org/spaces/zgc/pages/34668579/Main
> ZGC performs all expensive work concurrently, without stopping the execution of application threads for more than a millisecond. It is suitable for applications which require low latency. Pause times are independent of the heap size that is being used. ZGC works well with heap sizes from a few hundred megabytes to 16TB.
Go's GC is also very good: https://go.dev/blog/greenteagc.
V8's Orinoco is also pretty good now. It's improved a lot over the past decade and is now mostly-parallel. (A decade is about how long one of these things takes: high-performance GC is hard.)
I'm also a fan of MPS: it's a big of dark horse because it's more a GC construction kit than a ready-to-go GC, but it's fast and flexible, and I'd start with it any day over Boehm if I were making a VM from scratch.
That said: 1ms? 1ms is getting into the sorts of latency the OS and hardware impose on your program no matter what it does. For example, on x86, a SMI can take 300us, or 1000us if you're unlucky. I've seen softirqs for shitty wifi chips take a hundred milliseconds! And God help you if you take a hard page fault:
You're worried about 1ms latencies, right? So you're mlock()ing all memory? Running RT threads pinned to cores? Carefully using PI and static priorities to avoid inversions? Avoiding blocking IO everywhere, not even for graphics page-flipping? Managing thermal headroom to avoid involuntary clock collapses? And it should go without saying, but I have to ask: you're running a PREEMPT_RT kernel, right?
No? You're not doing any of these things? Then why are you worried about 1ms in GC?
Also let you remind that M:N scheduling was the FreeBSD's pthread implementation for quite a bit too long. No, it didn't play well with MySQL at the time.