Three things stick out to me on https://gossamer-lang.org/docs/migration/rust/

* No user macros at all. Six fixed format! / println!-family macros expand at parse time. - Meta programming is incredibly important in rust.

* (unsafe is) Forbidden at the language level. No unsafe keyword in Gossamer source. std is safe-Rust too. - No low level programming then.

* No move semantics. Non-trivial values are heap-allocated, reference-counted, and shared by reference; primitives are copied the same as Rust. - Again, no low level programming.

Calling this rust flavored (or even a systems programming language) seems a bit bold.

I can't figure out the point of having both go and spawn. `spawn` seems to be an ordinary thread spawning mechanism, generating a handle that you can join with (but not cancel? can't find that for certain, it's not actually in the tour but is in the SPEC.md). `go` inherits all the problems of go routines. You can't join with it, you can't cancel it, you have to build other infrastructure on top of it to achieve those effects. As neat as golang was 17 years ago when it came out, this was and still is a major weakness of the language which has resulted in the community developing conventions (now standardized in the go standard library and particular usage patterns) around how to deal with it. I don't get why you'd half fix it (by introducing spawn) but then leave it in anyways. Just let the handle from spawn be ignored and you remove that particular footgun (it becomes a choice to ignore it, which still causes problems but at least the programmer chose to shoot towards their own foot).

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'm fairly sure the code snippets aren't equal in the last python example:

```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.

This post reminded me of Swift– a modern high-performance language that uses automatic reference counting. Its got a REPL and compiles via LLVM. It does trade goroutines for something with a little more safety built in.

There was once a time when I'd see a page like this and think "wow, must be a great project with such a polished website".

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?

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.

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.

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.

Sorry but the name means bitterkid in french, I can't get over it :D

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.

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 but with automated memory management and without 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.