Discussion

sail0rm00n: I’m sold just for proper enumeration support.

bestouff: For "classic" Rust what's actually nice is that no runtime is needed, so this looks like a step backwards.What would be actually nice is running async Rust on the Go green threads runtime.

andai: In my experience, what's actually nice is the correctness. The low-levelness is not helpful for most of the software I write, and imposes a constant burden.Rust, of course superbly achieves its goals within its niche! But it is a niche, is my meaning here.What I actually want is code that's correct, but ergonomic to write. So my ideal language (as strange as it sounds) would be Rust with a GC.I don't want to worry about what string type I'm using. I want it to just work. But I want it to work correctly.Lisette looks like it's in this exact category! It seems to combine the best aspects of both Rust and Go, which is a very promising endeavour. I'll have to take a proper look :)

gf000: There are an endless number of modern MLs that do the same thing. That's not a novelty - Rust was novel in making it part of a low-level language.

baranul: There are several languages that compile to Go, trying to be a better a Go. Off the top of my head: XGo (https://github.com/goplus), Borgo (https://github.com/borgo-lang/borgo), Soppo (https://github.com/halcyonnouveau/soppo)...

Imustaskforhelp: No, this is actually nice to be honest. It's not a step backwards imo.if I can incorporate Lisette into my golang projects for example, (Invoking rust code within Golang to me feels like a larger problem and Invoking C might be easier from my tinkering experiments) I feel like you are viewing this from a pure performance metric but to be honest, most things aren't necessary to be the fastest, the type system of rust/rust-alike languages can be beneficial to people as-it-isCheck out gleam, its based on erlang so it has a runtime involved, people love gleam because it gives them a bit more expressiveness in the type system from what I've heard.I feel like these experiments are genuinely nice, Also perhaps a project like this can then slowly also invoke tinyGo (there was a recent discussion about it too) and could be compiled into tinyGo in future iterations to have no runtime essentially as well. People who love rust, love it, but most people really find it hard to get-into as compared to golang, I really love golang for its simplicity but I wish to tinker with rust too, so if Lisette combines both of these things and atleast makes me familiar with more rust without having to jump into too many hoops

akkad33: You can use Ocaml today and achieve all the correctness

lucianmarin: A programming language similar to Python that compiles to Rust or Go will be amazing.

IshKebab: OCaml has a lot of other cons though that Rust doesn't have. I would definitely pick Rust over OCaml even for projects that can tolerate a runtime with GC pauses. (And clearly most people agree.)

virtualritz: Looks great.But I can't help wondering:If it is similar to Rust why not make it the the same as Rust where it feature-matches?Why import "foo.bar" instead of use foo::bar?Why Bar.Baz => instead of Bar::Baz =>? What are you achieving here?Why make it subtle different so someone who knows Rust has to learn yet another language and someone who doesn't know Rust learns a language that has subtle enough differences that the knowledge doesn't transfer to writing Rust 1:1/naturally?Also: int but float64?

tux3: I don't think being low level is the main innovation, really. There are several things Rust did right over traditional ML. Explicitly caring about learnability and the "weirdness budget". Having great error messages that don't require a course in cathegory theory (many ML) or 800kB of scrollback buffer (C++) to understand.Having great tools. Excellent documentation. Being friendly to new users.Yes, it's also a systems language without a runtime. But that's not the novel part. You could write horrors in C++ that approximate ML even without language support. There are eldritch libraries where some kind of pattern matching is done via generic lambdas.The main difference is developper UX. Good tools, good error messages, quality of life. The novelty is making ML not painful.

kubb: Oh look, a better syntax than the Go team could design!

amelius: What benefit would it bring? There's already https://cython.org/

mememememememo: You want to use the Go runtime for example

amelius: How do compile errors propagate back from the target language to the source language?

Hasnep: Spy (https://github.com/spylang/spy) is an early version of this kind of thing. I believe it compiles to C though, kinda like Nim. Actually speaking of Nim, that's probably the most mature language in this space, although it's less platonic than Spy

rubymamis: Mojo is a language with Pythonic syntax that compiles to fast machine code built by the creator of Swift: https://www.modular.com/open-source/mojo

emmelaich: Here you are. https://github.com/google/grumpyLast commit was 9 years ago though, so targets Python 2.7.

usrnm: They are not supposed to produce code that doesn't compile, why would they?

Comma2976: Nuh uh

melodyogonna: I'm wondering about the logistics of making this integrate with Go at the assembly/object file level rather than at source code level. What if it compiled to Go's assembly rather than to Go source code

rednafi: [delayed]

thrance: I think "Because (the dev) prefers it that way" is a satisfactory answer. Often, these small languages don't aim to be used in production and become the next big thing. They're made for fun and exploration's sake.

amelius: What cons?

zorobo: For example, multicore OCaml is not free of race conditions. The GC, while super efficient (pauses are in the milliseconds), is not suitable for hard realtime.Still, where absolute max performance or realtime are not required, I'd choose OCaml as it is elegant & a pleasure to code in (personal opinion, ymmv).

rbbydotdev: Looks beautiful! Any plans to make it self compile?

mirekrusin: MoonBit [0] is the best/future complete/active “rust with gc”.[0] https://www.moonbitlang.com

sheept: These are just syntax differences, which not only are easy to learn but I believe aren't the primary goal of the language, which is to bring the benefits of Rust's type system to Go.As for int and float64, this comes from Go's number type names. There's int, int64, and float64, but no float. It's similar to how Rust has isize but no fsize.

darccio: Having explored that approach (), I can tell that generating Go assembly is harder than it seems.: I've tried to transpile Rust code through WASM into Go assembly, and I've also explored to inject trampolines into Go binaries (which involves generating Go assembly too).

ksec: On the surface this looks great. Seems to hit the sweet spot in a lot of areas.I know it is Rust inspired, but why write it in Rust and not Go?

bhwoo48: Love the idea of bringing Rust ergonomics to the Go runtime. As someone currently building infra-automation tools (Dockit), the trade-off between Rust's safety and Go's simplicity is always a hot topic. This project addresses it in a very cool way. Will definitely follow the development

melodyogonna: That is interesting, but I imagine Rust has features which can not be translated into Go's assembly. This language is specifically designed for Go interop; the logistics wouldn't be the same, though I still expect it to be difficult.

masklinn: > It's similar to how Rust has isize but no fsize.isize is the type for signed memory offsets, fsize is completely nonsensical.

masklinn: > Yes, it's also a systems language without a runtime. But that's not the novel part.Low level strong correctness was absolutely a novel part. In fact it’s exactly why many people glommed onto early rust, and why it was lowered on the stack.> horrors in C++Yes, horrors in C++. Half baked jerry-rigged and barely usable nonsense. Not an industrial strength langage with a reliable type system and a strong focus on safety through types.

masklinn: > all the correctnessWhen did OCaml get affine types?

apatheticonion: Same. I started writing a high level Rust that was based on typescript.Then realized Rust wasn't that hard.

emehex: Looks a lot like Swift! Awesome!

thomashabets2: I've chatted a bit with the author, but not actually tried the language. It looks very interesting, and a clear improvement. I'm not particularly quiet about not liking Go[1].I do think there may be a limit to how far it can be improved, though. Like typed nil means that a variable of an interface type (say coming from pure Go code) should enter Lisette as Option<Option<http.Handler>>. Sure, one can match on Some(Some(h)) to not require two unwrapping steps, but it becomes a bit awkward anyway.Lisette also doesn't remove the need to call defer (as opposed to RAII) in the very awkward way Go does. E.g. de facto requiring that you double-close on any file opened for write.Typescript helps write javascript, but that's because until WASM there was no other language option to actually run in the browser. So even typescript would be a harder sell now that WASM can do it. Basically, why try to make Go more like Rust when Rust is right there? And fair enough, the author may be aiming for somewhere in between. And then there's the issue of existing codebases; not everything is greenfield.So this seems best suited for existing Go codebases, or when one (for some reason) wants to use the Go runtime (which sure, it's at least nicer than the Java runtime), but with a better language. And it does look like a better language.So I guess what's not obvious to me (and I mentioned this to the author) is what's the quick start guide to having the next file be in Lisette and not Go. I don't think this is a flaw, but just a matter of filling in some blanks.[1] https:&#x2F;&#x2F;blog.habets.se&#x2F;2025&#x2F;07&#x2F;Go-is-still-not-good.html

smw: Rust's async story is much less ergonomic than go's -- mostly because of lack of garbage collection. That might be a good reason by itself?

jech: The ecosystem. The language is lovely, but dune&#x2F;opam is not up to the standard of the Go or Rust build systems, and the set of useful libraries is somewhat skewed. Whenever I write a program in Caml, I gain an hour thanks to the nice language, and then lose two fighting with dune&#x2F;opam.There's also the support for concurrency and parallelism, which has started to improve recently, but is still years behind what is available in Go (but still better in my opinion than what is available in Rust).

bluebarbet: Eats shoots and leaves.

debugnik: Debugger positions on the other hand are a pain with these things.

amelius: Uh yes, that's what I meant ;)In C&#x2F;C++ you have the #line preprocessor directive. It would be nice if Go had something similar.

siwatanejo: F# is very similar to python because it's based on indentation instead of curly braces. And with Fable you can transpile it to Rust (or Python even): https:&#x2F;&#x2F;github.com&#x2F;fable-compiler&#x2F;fable

oncallthrow: I've read the entire page and still don't know whether or not I can import Go modules in this language, which seems rather important

OJFord: Really? Almost every example imports something from Go, and it states "interoperability with the Go ecosystem" (or similar, from memory).

oncallthrow: That isn’t the same thing. Indeed, upon reading further, it appears there is no way to import non-stdlib go modules.

troupo: Because it's inspired by Rust, but doesn't try to be Rust? And it's aimed at Go developers?

zozbot234: > Basically, why try to make Go more like Rust when Rust is right there?Go gives you access to a compute- and memory-efficient concurrent GC that has few or no equivalents elsewhere. It's a great platform for problem domains where GC is truly essential (fiddling with spaghetti-like reference graphs), even though you're giving up the enormous C-FFI ecosystem (unless you use Cgo, which is not really Go in a sense) due to the incompatibilities introduced by Go's weird user-mode stackful fibers approach.

smokel: This is great news for those of us looking for baby names. So far my list includes: Pascal, Ada, Dylan, Crystal, Lisa, Julia, Ruby, and now Lisette.

tempaccount420: Please commit your CLAUDE.md

emanuele-em: Really nice work on this. The error messages alone show a lot of care, the "help" hints feel genuinely useful, not just compiler noise.I'm curious about the compiled Go output though. The Result desugaring gets pretty verbose, which is totally fine for generated code, but when something breaks at runtime you're probably reading Go, not Lisette. Does the LSP handle mapping errors back to source positions?Also wondering about calling Lisette from existing Go code (not just the other direction). That feels like the hard part for adoption in a mixed codebase.Is the goal here to eventually be production-ready or is it more of a language design exploration? Either way it's a cool project.

ivov_dev: Thanks for your kind words :)The CLI command `lis run` supports a `--debug` flag to insert `&#x2F;&#x2F;line source.lis:21:5` directives into the generated Go, so stack traces from runtime errors point back to the original Lisette source positions. The LSP handles compile-time errors, which reference `.lis` files by definition.Calling Lisette from existing Go is not yet supported and is the harder direction, as you noted. This is on my mind, but the more immediate priority is enabling users to import any Go third-party package from Lisette.Lisette began as an exploration, but I intend to make it production-ready.

uecker: Memory safety is not the same a scorrectness and more advanced type is also not the same thing as correctness.

jasdfwasd: Could large data types be problematic for the prelude types Option&#x2F;Result&#x2F;Tuple? They don't store as pointer and every receiver is by value.

knocte: From your blog entry:> Go was not satisfied with one billion dollar mistake, so they decided to have two flavors of NULLThanks for raising this kind of things in such a comprehensible way.Now what I don't understand is that TypeScript, even if it was something to make JavaScript more bearable, didn't fix this! TS is even worse in this regard. And yet no one seems to care in the NodeJS ecosystem.<selfPromotion>That's why I created my own Option type package in NPM in case it's useful for anyone: https:&#x2F;&#x2F;www.npmjs.com&#x2F;package&#x2F;fp-sdk <&#x2F;selfPromotion>

sa-code: > Basically, why try to make Go more like Rust when Rust is right there?The avg developer moves a lot faster in a GC language. I recently tried making a chatbot in both Rust and Python, and even with some experience in Rust I was much faster in Python.Go is also great for making quick lil CLI things like this https:&#x2F;&#x2F;github.com&#x2F;sa-&#x2F;wordle-tui

thomashabets2: No doubt a chatbot would be built faster if using a less strict language. It wasn't until I started working on larger Python codebases (written by good programmers) that I went "oh no, now I see how this is not an appropriate language".Similar to how even smaller problems are better suited for just writing a bash script.When you can have the whole program basically in your head, you don't need the guardrails that prevent problems. Similar to how it's easy to keep track of object ownership with pointers in a small and simple C program. There's no fixed size after which you can no longer say "there are no dangling pointers in this C program". (but it's probably smaller than the size where Python becomes a problem)My experience writing TUI in Go and Rust has been much better in Rust. Though to be fair, the Go TUI libraries may have improved a lot by now, since my Go TUI experience is older than me playing with Rust's ratatui.

stevefan1999: Well that's why I decided to go C# for general purpose stuff

smt88: How would TS fix null in JS without violating its core principles of adhering to EcmaScript standards and being a superset of JS?

debo_: Nim looks a lot like Python with a first-class type system and compiles to many different targets, including wasm and C.

alpinisme: Your readme would really benefit from code snippets illustrating the library. The context it currently contains is valuable but it’s more what I’d expect at the bottom of the readme as something more like historical context for why you wrote it.

thomashabets2: Does Go actually have an async story? I know that question risks starting a semantic debate, so let me be more specific.Go allows creating lightweight threads to the point where it's a good pattern to just spin off goroutines left and right to your heart's content. That's more of a concurrency primitive than async. Sure, you combine it with a channel, and you've created an async future.The explicit passing of contexts is interesting. I initially thought it would be awkward, but it works well in practice. Except of course when you need to call a blocking API that doesn't take context.And in environments where you can run a multitasking runtime, that's pretty cool. Rust's async is more ambitious, but has its drawbacks.Go's concurrency story (I wouldn't call it an async story) is way more yolo, as is the rest of the Go language. And in my experience that Go yolo tends to blow up in more hilarious ways once the system is complex enough.

Matl: For one, I am glad I don't have to color my functions like your typical async.