Birbla

Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

Sign in
  • Hacker News
  • Does it have a REPL? That's been one of the greatest sins of Rust - designing a compiled language after 1990 that doesn't have an interactive REPL.
    by throw10920
  • 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.
    by samuell
  • Haskell, Java
    by gf000
  • Green threads predate modern async/await by quite a long way. Since async/await was developed, recent languages tend to prefer the ‘principle of least surprise’ by making the yield points explicit, since they interact in important ways with the code around them, with the notable exception of Go (which is very weird considering how explicit they decided to make their error handling).
    by Twey
  • 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.
    by kccqzy
  • 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.

    by jeremyjh
  • Just a comment: Rust does not have a garbage collector
    by LunicLynx
  • 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.

    by IshKebab
  • Why not embedded rust?
    by cure_42
  • 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.

    by quotemstr
  • 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.
    by smj-edison
  • > We have multiple open-source pauseless miracles GCs right there in front of us

    Can you share some links/references?

    by iyn
  • > 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?

    by platinumrad
  • 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.
    by sdicker
  • 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?

    by throwrioawfo
  • you know what's even worse than slop? Zero-effort 'is this maybe slop can someone tell me' posting.
    by felixgallo
  • 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.
    by sesteel
  • It's clearly vibecoded if you look at the commit history.
    by bscphil
  • A card grid with rounded corners as the second section and a dark blue or purple theme just scream "designed by Claude".

    It's decent design, but not a useful quality signal.

    by Zak
  • 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.

    by klardotsh
  • 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.

    by pantsforbirds
  • Also the Python sorts by string content and the Gossamer sorts by string length.
    by mkl
  • 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).
    by Jtsummers
  • 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
    by rsyring
  • 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 :)

    by etaioinshrdlu
  • 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.

    by reocha
  • All three points are erased by its ability to call Rust functions…

    It’s not a bad approach, in that for most general programming one doesn’t need those things. Granted, macros can be convenient.

    by Recurecur
  • This language reminds me of Borgo https://borgo-lang.github.io
    by norman784
  • Totally agree, misleading.

    The syntax looks like rust, but esp w/the memory management model (reference counting), it’s going to have more overhead than rust when it’s running, more like Swift or at worse, Python.

    by bfung
  • Google called Go a "systems language". I agree its not the right term, but people do use it to describe a language used in infrastructure software like Docker or Kubernetes.

    To me it makes a lot of sense as a starting point. The world does not need another Rust since we have a perfectly good one. People who like Rust's type system but don't care to think about ownership when writing application code, and who appreciate the language asyncing all the things invisibly have plenty to like here.

    I do agree though any serious language MUST have an FFI capability, and macros or at least some form metaprogramming of seem like tablestakes. Green threads are not impressive if they are not preemptive. But its not describing itself as finished, its 0.19. Rust looked completely different at that stage in its development - I think it still had green threads itself at that point.

    by jeremyjh