The Goose Programming Languageaardappel.github.io
Obviously the guy is replying to something that you can't see without logging in twitter. And without context this means little
>Obviously the guy is replying to something that you can't see without logging in twitter.
I could follow the link and read the thread and I don't have an X account.
You can also check out the language's website by googling "goose programming language", which should lead you to: https://aardappel.github.io/goose/index.html
the rest of the thread yes but not the thread before
The link to the github works. Everything else opens google play store page for twitter for me.
The Twitter/X link doesn't show the full thread without a login. It also doesn't tell you that something is missing, so I guess it's normal for people to think they're seeing everything.
What X shows me: https://celsoazevedo.com/files/2026/x.webp
With a login/nitter: https://celsoazevedo.com/files/2026/nitter.webp
He should've posted the website instead of twitter
Twitter is gone, in more ways than one. RIP.
Better than ever tbh
Such a cool idea! I've been toying around making a few libraries to force languages to do that direct io zero-read mapping to data structures. Ofcourse this looks way better and infinity less hacky, but it is a fun and trippy experience to find someone working in the same direction as you independently.
Btw I made the language, AMA. repo: https://github.com/aardappel/goose
If you had no other obligations and todos getting in the way, what's the first thing you'd rewrite in Goose yourself?
(And why isn't it Amiga E?)
Most of my current Goose projects are games, not surprisingly, but I have some language/tooling ideas as well.
As for Amiga E, I am very proud of having made it way back when obviously, but it doesn't stack up against my more modern languages (Goose and Lobster), so I think I'll leave it be :)
What happens if the memory is freed in a different order to allocation? Does the language disallow that? Or does it get allowed but mean the stack can't shrink?
How are you deciding how many stacks to use?
The compiler automatically optimally allocates all arrays currently in scope that are able to grow to "stacks" (address spaced reserved areas).
The programmer choose what to store where, so you typically store things in arrays by lifetime. Goose gives you many more tools to do that, it can store entire variable sized trees of an enum type in a single array.
You try to avoid having to deallocate in mixed/random order, but if you absolutely must, you can turn arrays into pools, basically.
─ 5 more ─
Thanks!
I'm a bit confused about how you could decide the number of stacks at compile time. I can see you could see how many arrays are lexically in scope. However if the code puts one dynamic array inside another dynamic array I can get to an unbounded number of total stacks without ever needing more than two in lexical scope at once. Do you also add stacks at runtime? Like a stack of stacks?
─ 4 more ─
The top level arrays all are owned by a local variable. An array of arrays is just allocated to a single stack.
─ 3 more ─
I'm sorry if I'm being dense here but I can't see how that would work?
The spec on your GitHub says: "Two simultaneously-live resizable values never share a stack."
So I surely can't have a dynamic array of dynamic arrays share a single stack? That's an unbounded number of resizeable values sharing a stack?
You could make it work on a single stack but that would involve having non-contiguous memory for each inner array since you can add to any array in any order.
The spec implies that we need one stack per element of the outer dynamic array which would let you have contiguous memory for each inner array, but you wouldn't know how many stacks you needed at compile time.
─ 2 more ─
The language has different levels of solutions for the inner arrays being dynamic, for example a) only dynamic upon construction, b) fixed size, c) fixed size with cap, or d) allocated in a pool in a different array.
Depending on your needs you use one of these solutions.
─ 1 more ─
Makes sense now. Thank you!
You noted AI creating a large amount of this code base with yourself directing it. Do you have a process that keeps you sane while doing this over such a large codebase?(especially for a brand new concept and implementation) [Obviously congrats and can't wait to read through to have deeper questions!]
A big part of this making it base the code of this new compiler on my previous compiler for the Lobster Programming Language. I had it go thru that codebase, distill an elaborate code style guide from it, and used that to make it write the new code pass by pass in that style. That made me feel "at home" as if it is my code, easier to review etc, and easier to know we're going in the right direction by seeing similar structure to my past compiler work.
Once the initial compiler was there it became easier, as Fable is rather good of working within the context of what is already there.
─ 1 more ─
Thanks much appreciated!! Feeling silly for not noticing my best experience with AI in larger/complex cases has been languages/frameworks that are opinionated in usage/design(zig/go/elixir/rust)
First, Congrats on the release!
Do you know if Goose is the first time something like this has been done?
In this particular combination, most certainly.
There is lots of prior art on the individual parts of the design, e.g. "regions" and various stack languages etc, see: https://github.com/aardappel/goose/blob/master/docs/design/p...
Part of this is that 64-bit address spaces make this design practical, and almost all languages in use today were designed with the limitations of 32-bit in mind. Once you can assign arrays huge amounts of address space, you don't have to realloc, which gets you stable pointers, and a lot of the other Goose features.
Is this like forcing the escape analysis of the compiler to be perfect, by making it explicit in the programming language?
I'm wondering what kind of architectural corners this forces the programmer into ... have you found any so far?
Yes, the compiler guarantees references to data structures can't escape. I believe it does that "perfectly" :)
It certainly requires the programmer to rethink how they structure their data, as you have to think of where it is going to be stored, and how to store it in a way such that it will have similar lifetimes to what it is stored with, to get the most out of the language.
What does this mean (from your link):
>Nested data stays inline. A string, an array of strings, a record with variable-size fields and an array of those records are each one contiguous block with no pointer in it. A record that is 160 bytes and an allocation in C++ is 29 bytes and none in Goose.
I’m having trouble parsing that last sentence.
I parsed it as "A record that is ((160 bytes and an allocation) in C++) is ((29 bytes and none) in Goose)."
So, I read it as, "C++ uses 160 bytes and an allocation, when Goose requires 29 bytes and no allocation".
It means that to do variable sized things like vectors and strings, C++ often ends up having to allocate their contents dynamically. Which results in data structures with lots of 64-bit pointers over multiple allocations.
Even Rust's "enum" feature, which can store different sized things all in the same space, does that at the cost of the smallest variant being just as big as the biggest.
Goose can do all of that not only inline (no pointers), but with variable size, meaning small items take less space. It's like a serialized data representation, but iterable. It makes for big space savings vs these languages.
─ 14 more ─
These AI generated docs would make more sense if you instruct it to not include numbers unless they form a complete example.
As far as I can tell, you're essentially creating a new stack for every dynamically-sized variable (because otherwise nothing would be able to grow by bump allocation without moving). But this means you're creating a separate virtual memory allocation for each of these objects, which (I presume?) then rounds the size up to the OS's minimum page size (4KiB or similar).
Doesn't that waste a lot of space? Or is there something I'm missing?
Also it would seem to force every allocation to go through the OS kernel to allocate unless there's some trick to avoid that.
─ 9 more ─
Only top level growable arrays get their own "stack", if you create an array of arrays it only uses one stack.
How you deal with the inner stack growing depends, ideally they don't grow (construction only), or you can make them fixed size, or with a capacity, or in the worst case, as a pool. The language has facilities for all of these.
─ 2 more ─
What’s the “pool” case? A function allocates a growable arena in normal heap or virtual memory?
─ 1 more ─
I think what you might be missing is that you can also do a sort of livenes analysis to determine how many dynamically-sized variables are "awake" at the same time at most. Then you only need to create as many stacks as that number, because you can reuse the stacks of "sleeping" variables (since the "awake" variables are guaranteed to be freed once their block goes out of scope, and threads don't share any memory so no data race worries regarding those stacks).
For example, suppose we have a function with a growable array that calls another function (without passing said array) that also uses a growable array as some temporary scratch space. Then the first function's array isn't being used when the second is sleeping, so the inner function's array could safely share the stack because it will all be freed with a single pointer restore once the second function exits.
Now, I actually don't know how the compiler works but as I understand it does things similar to my example to optimize the number of stacks needed (but let's wait for WvO to confirm or deny whether my understanding matches reality).
─ 3 more ─
The obvious question is how does it work for linked lists, trees, and other non-stack-shaped data structures?
─ 2 more ─
At the end of the day trees are still stored linearly in memory. Think of it as an array, with each node an element of the array, and indexes used rather than pointers.
Plenty of trees only ever grow. And that's the normal type of array in Goose. However you can also have arrays that can grow and shrink, if you have a tree that is constantly in flux.
Either way it'll be one stack for an entire tree.
There are examples in the tutorial, including a circular linked list.
You can just store all them items of the list/tree/whatever on the stack, growing it as needed, or you can add an addition "freelist" for a particular stack, so you can re-use items.
All it's doing is allocating address space. And 64 bits means you have an astronomical amount of that. It only needs to become actual memory when you use it. A page at a time.
─ 1 more ─
>All it's doing is allocating address space. And 64 bits means you have an astronomical amount of that.
No, you can typically only assume 48 bits of virtual address space; the kernel takes half of it, so really only 47 bits. Newer CPUs provide 57 bits (e.g., Zen 4) or 52 bits (certain ARM64 models). And that's provided that the kernel plays ball; apparently some Android configurations only support 39 bits of user virtual address space.
I wish it was more clear about the memory layout of nested variable sized data structures. As far as I can work out the max capacity is decided at construction time which makes the whole thing a lot less intriguing.
You can also just do that in C++. I do that as part of my messaging usually, so that the objects are trivially relocatable and reinterpret-castable. It only works so long as you combine a set of canonical types, but that can be verified or converted using C++26 reflection.
I have both what I call inline sequences, and out-of-line ones (store an offset to the object itself rather than pointers).
I made all my sizes and offset 32-bit, but I suppose they could have been 16-bit.
─ 1 more ─
This is also the default C behavior.
Do you consider Goose to be a replacement for Lobster, or do they fill different niches?
I think they have slightly different places on the "speed vs ease of use" pareto frontier.
With Goose, the core design favors speed over everything else. Though not only was I able to make that safe, it is fairly pleasant to use. But it remains a low level systems language that requires you to think hard about data organization.
Lobster is a waaay more high level language made to be pleasant to use first, fast second. Surprisingly though, it can get pretty close in speed to C++/Rust nowadays too, but still a lot slower than Goose.
─ 8 more ─
Do you have plans to continue using AI to improve Lobster too, e.g. working on implementation speed, or perhaps self-hosting?
How have you found AI at writing Goose or Lobster code, if you give them a skill or something, are they relatively competent at actually writing code in the language?
Both are really interesting projects, BTW - thank you! I've been meaning to try Lobster out but haven't found time, I think this might be the push I needed.
─ 7 more ─
I've already been improving Lobster's speed a lot in recent times: https://github.com/aardappel/lobster/blob/master/tests/compa...
Self-hosting would be cool too, but for both Lobster and Goose I've tried to keep it simple for people to build the language in any environment, which is why its still all in C++.
I don't use any "skills". From what I can see, the #1 way an AI produces "good code" is to simply work in the context of existing good code. I don't need to hold it by a style guide, it seems to infer that from context just fine. At least Fable does, other models less so.
─ 6 more ─
>From what I can see, the #1 way an AI produces "good code" is to simply work in the context of existing good code.
"Just Git Gud First" - Wouter van Oortmerssen
─ 2 more ─
That's unnecessarily dismissive. I find the statement quite enlightening and I wish other engineers would realize the wisdom here.
LLMs are pattern matching machines. Your code is the base template that will determine all patterns moving forward. No amount of context engineering or prompting can save your code from itself.
Pragmatically, it suggests we need a much greater investment in code quality, and much less hand-wringing over AI tooling.
─ 1 more ─
Apologies, I wasn't trying to be dismissive, it was meant to be a joke that the sentence read like an (earned) humblebrag.
For context: I'm very active on the Goose discord (and have been following WvO's languages since Lobster was announced on Google Groups eons ago). I goof around there too, and forgot for a moment that outside of that chat it wouldn't be obvious that I'm being tongue-in-cheek.
I suppose something like a skill would help those starting with the language. If nothing else, a well written skill can be read by a human - or you could load the skill and generate a program you are familiar with.
How do you ensure that bootstrapping a new project has good code?
─ 1 more ─
As I mention at the end of https://github.com/aardappel/goose/blob/master/README.md I essentially had it use a previous compiler of mine (Lobster) as a template.
Even if you don't have such an example, pick a project that you think has "good code" (even if it is not your own), point the LLM at it, tell it to have a deep read of the code, and come up with a very in-depth coding guideline in a .md file with code patterns etc. Then put that .md in your new project and tell it to follow it.
>Threads that share nothing. A worker is compiled as a separate program with its own memory, and flat values cross typed queues as a memcpy. Data races, locks, atomics and memory orderings do not exist in the language.
how to perform this copy without atomics?
do the workers run as threads or processes?
also you claim it's faster than rust and c++. but for certain kinds of software it's certainly (and substantially) slower, right?
The copy is made by the runtime, which obviously does use atomics underneath, but you don't ever use these yourself.
The workers are threads. The separate memory is the concurrency model, but it's still single process, multiple threads.
The "faster than" is on average, and both in my own benchmarks and independent benchmarks you can find examples of algorithms where it is slower, but they tend to be the exception. "substantially" slower I haven't found yet.
─ 5 more ─
That site is just benchmarking how well an AI can implement things, it has nothing to do with how "fast" the language is.
─ 2 more ─
>It evaluates 27 programming languages across 50 real-world-inspired tasks using 5 metrics: runtime, runtime score, memory usage, compile time, and expressiveness.
─ 1 more ─
I'm not sure how that is relevant to every test being vibe-coded?
>The "faster than" is on average, and both in my own benchmarks and independent benchmarks you can find examples of algorithms where it is slower, but they tend to be the exception. "substantially" slower I haven't found yet.
Well message passing with literal memcpys (rather than, say, just a shared buffer, like is common in Rust) is very expensive when the messages are huge. Of course as the message size increases, the Rust program will become faster than the Goose one (and if it doesn't, you should look into your benchmarks)
Being more specific, it means that for each message, we are writing on memory twice - one to build our own buffer with the message, and another to make a copy to another worker. Message passing violates, in spirit, the Goose rule that things are built on their end destination: we can't write into a buffer owned by another task, so we need to first write on our own buffer, and then do a copy, which is a lot like first writing the value to the stack, then copying the heap. Writing twice has an overhead, specially when messages don't fit in the cache - you just need benchmarks with sufficiently large messages to demonstrate it.
Beyond that, there are some algorithms that can be made much faster when written with atomics rather than message passing. (Also there are algorithms that will get faster if you use locks! Locks aren't always slower). It's just a matter of finding such examples, and writing a Rust code that will use atomics, compared to a Goose program that uses messages between workers because Goose doesn't expose atomics to the user.
So if you didn't find such examples, it's because you didn't specifically write benchmarks with those scenarios in mind (or, I mean, didn't told your LLM to write this).
That is: if the Rust program and the Goose program do the same thing in the same way, then it's reasonable that Goose is faster on average. But Goose is limited because it doesn't let you do some things, but Rust does, so to compare the languages you need to find those cases where the Goose limitations end up making the software slower
─ 1 more ─
Sure, those cases could bite. I think all my benchmarks (and external benchmarks) are mostly single threaded.
Note that all this supposed copying overhead also has an upside: once the synchronisation has happened, every thread can now run at maximum speed doing single threaded memory allocation with no locking of any kind.
In C++, malloc/new in multithreaded programs needs to essentially go thru a mutex and can make allocation even more expensive than it already is. I am not sure if Rust does the same.
Since in Goose "allocation" is just a pointer bump, we cannot make that multi-threaded, hence the threading model followed from that.
And like a lot in Goose, you have to write your program to fit the language a bit. If you expect to do concurrency on top of a huge graph of constantly changing data that all threads must have immediate access to, it is probably not the language for you. But there are plenty of concurrency models that fit and are blazingly fast.
Sounds like they are processes, as the docs say that all the global data is duplicated for the workers to have a private copy.
Why are you pretending that John is endorsing your project?
Why was it named Goose?
I've named many of my past languages with animal names, e.g. Lobster. Goose just popped into my head as cool sounding at the time. It has no special meaning.
─ 2 more ─
I feel the need, the need for speed. Talk to me, Goose.
Thank you.
I would throw the entire docs out and write it from scratch in your own words. I get that we live in an era where the machine writes most/all of the code, and I can accept that. What I need, to even consider using and extending this project, is some understanding of what part of the design is yours and what part is accident by Claude. I can't get that from reading Claudese.
We as a society have to cut this low effort commenting out. The documentation is perfectly comprehensible. What action would you take differently if a given feature were implemented by Claude, or a human?
─ 32 more ─
As I said in my message, it would determine whether I use the project or not. I need to match it to my use cases, and if I find a match I need to know: is it matching because my use case falls in the domain of what the human collaborator wants from this project, or is my use case a hallucination that will go unsupported?
You cannot tell either from the AI written docs. I'd rather OP gave a rambling post about some problem he has in gamedev that led him to think a new language was needed, why the constraints are different, and how this will improve X, Y, or Z in his own words. Then I can infer what this project is and where it is going. Right now, I have no clue.
─ 15 more ─
The docs are perfectly legible and to the point. I don't see the need to waste the author's time with aesthetics
─ 1 more ─
Legibility is not the concern. The issue is whether the point the docs are making are the actual point the author is concerned with.
With respect, what on earth are you talking about? The documentation is clear about what the language does. You can download it and test it out if you like, and verify if yourself if the documentation matches the feature descriptions. What the human collaborator wants is immaterial. You get the code.
The author has written that post about why the language came about. He doesn't owe you that, but he did it anyway. He doesn't owe you anything more. You can use it or not. Advising him to throw away all the documentation and rewrite it again by hand from scratch so that adastra22 can deign to examine it further is ridiculous.
If you have a question about whether or not this further iterations will fit your specific (and so far undescribed) particular use case, the correct avenue for that is to ask the author politely. Or Fable; Fable could probably tell you without having to bother the author. But holy cow, the entitlement.
─ 8 more ─
Are we now in a situation where all code is disposable, throwaway things with no long-lived projects?
We're talking about a programming language. Languages, and their compilers, evolve over time. Where is this one headed?
─ 7 more ─
If you think you'll be able to divine that if and only if the documentation is entirely written by a human, then I'm afraid I'll have to disappoint you: no language has ever evolved strictly according to the initial plan of their authors. Nor has any author's strongly held belief about the future ever panned out the way they thought. Nor has the documentation ever held the immutable future of the language, even when fully human generated (which essentially zero languages have, even before AI).
The way to find out if a language is suitable for your needs is not to demand, in an entitled way, that the author perform an act for you. It is to (a) ask the author politely; or, failing that, (b) to examine it yourself (or ask Fable to evaluate it, using tokens you paid for).
This particular language, further, is Apache 2.0 licensed. If it's not working for you, fix it. Jesus.
─ 2 more ─
Your correspondent keeps moving the goalposts and never presents a coherent argument. I would just leave them be.
─ 1 more ─
How have I been inconsistent?
pretty much that's the default assumption yeah. Anything new is probably a throwaway. If there's anything cool in it - rebuild it to your own taste. There will be exceptions that do become long lived projects of course. probably even the same amount there were before. But there's going to be a few orders of magnitude more throwaways so on average any new piece of code is going to be a throwaway
─ 2 more ─
Do you not see the problems that arise here? Are we losing our accumulated engineering best practice knowledge? Standardized, common, highly reviewed subsystems provide working engineering know-how and accumulated lessons learned. Not even the best AI systems can keep that many considerations in mind when re-spinning code.
If this is your default assumption, I hope I never have to rely on code you generate.
─ 1 more ─
Who said it's my assumption for code I generate? We're talking about how I evaluate code other people generated. If that wasn't my default assumption - then you should never trust anything I create because I would be naively trusting other people to maintain throwaway projects.
Are we losing our accumulated engineering best practice knowledge? Yes. Have you seen the quality of new hires recently? The ones who've cheated their way through school and don't know what a for loop is? People that have those skills aren't letting them atrophy but the chain of transmission is in crisis. Breaking news, sometimes things suck
with programming languages which just rehash ideas (not saying it's a bad thing mind you! a good mix is better than a sum of its parts) you can nowadays get literally years of work in a week. truly novel stuff like bend2 takes longer (ask Victor), but I expect the next generation of models to compress those timelines, too (if the next generation is allowed to be released, since the security brouhaha going on now is seriously concerning)
Seems like an AI could be tasked with verifying the docs. Then a human can double check it's work if it finds anything.
─ 2 more ─
Verify against what? What I want verification against lives in the human's head, not the repo.
─ 1 more ─
Oh, I was thinking verify what the doc claims to what the code actually does, I misunderstood you.
What's left to determine? Obviously AI written docs are a deal breaker for you. Seems very straightforward. If docs are ai written, move on. That's an immediate and obvious fundamental incompatibility you have with the project. Why are you still complaining about the docs being ai written getting in the way of making your decision when you've clearly already made it?
Why are low effort comments not worthwhile but low effort docs are fine?
If you've ever been tasked with coming up to speed on a system mostly documented with AI writing, you'll quickly realise how hard it is to trust anything you are reading. Even if the Claude documentation is 100% accurate, you'll never shake the worry that some crucial fact you founded your understanding on was wrong. It's a fast recipe for psychosis.
That's without even mentioning that AI writing can often state the what but not the why. That human perspective is usually the most valuable knowledge to get across in writing.
─ 9 more ─
There’s no reason to trust a human any more than an LLM for this. Humans are not 100% accurate and very capable of making crucial factual errors in documentation. Ask me how I know.
─ 7 more ─
There’s a _very_ good reason. Humans have a much richer mental mental model of the codebase, design decisions, external factors, etc.
Of course Humans can make errors when translating that to English. But if you’ve read any amount of Claudish it should be obvious that interpolating the code to documentation with an LLM typically produces a significantly worse result in almost every way. Except for superficially “sounding” correct.
─ 3 more ─
That’s just not true especially when the author designed the language with the LLM like he says in the end (the AI is very good at forcing you to be specific and make decisions on ambiguous terms): all decisions can be included in the repository in a way the computer can follow and understand, which is a pattern called specification graphs. You can just document things in the docs as well if you want a more basic method. If you are claiming this language is worse in every way than others that were made by humans alone, could you be specific?? What are the bad things you’ve found? What part of the docs are incorrect? Or are you just commenting without having looked at any of that?
That is not necessarily true if the codebase is written by AI unless the human chose to be involved. That was also not necessarily true before AI either. Human skill level is wildly variable
Above all, I think I like human docs because then I not only know someone has a deep understanding of it, but also that someone can actually be queried about it. With Claude, there is always the accountability problem. If something seems off, do I even have someone other than Claude that understand it all and who is accountable ?
I don't want to read software written by misanthropes. If you've given up on working with other people, then what is the point exactly?
─ 1 more ─
Amen. Not to mention these people usually want others to laud them for creating a world they can't bring themselves to actually live in.
If you believe you are making something worth other people's time, you should ALSO believe you are making something worthy of your own time.
It's probably possible to prompt an LLM into writing well, but most LLM writing that I've seen is poorly structured (e.g., the paragraphs in this post feel like strings of punchy marketing phrases), and the LLMs are too good at sounding like they're saying a lot while saying very little.
Plus, if a human puts the effort into writing something, that signals to me that it's worth something, because human time is much more scarce than LLM time.
at that point i just ask an ai questions about how the system works and hope the reasons for particular decisions can be reverse engineered from git history/pr comments etc.
I find your comment much much lower effort than GP you took a snip at. It's true that more ppl may align in your thinking, but dissing the other side's concern as low effort does not belong in hn.
>What action would you take differently if a given feature were implemented by Claude, or a human?
This one is easy: I'd read the docs if it were written by a human, but I won't read them if they're written by Claude.
Comprehensibility does not equal correctness or fitness. As if that wasn't enough, or perhaps in most related manner, an LLM/AI cannot be held responsible for what it produces, by nature, especially considering the fact that a _human_ claims all of it as their own work, or at least take responsibility. Meaning that when a parable of documentation is discovered to be bogus, you can't pin it on AI, you go to the human and ask them why the documentation is wrong, and it's not a good look.
>The documentation is perfectly comprehensible
For a programming language? It's subpar and you know it.
See this for a language docs site by a small-ish team, but a significant effort was put into making it nice to read: https://tour.gleam.run/everything/
>The documentation is perfectly comprehensible
That's, like, a stunningly low bar for documentation. "The vehicle is perfectly capable of performing motion, why are you complaining?"
The version of the documentation which I would very much like to see would be a Literate Programming version where all the code is explained from the ground up.
Apparently, this can actually assist the LLM:
https://silly.business/blog/we-should-revisit-literate-progr...
as discussed here previously:
─ 5 more ─
That's a great idea. I wonder if any major library (or language) has attempted a version their site in that style.
I'd love to experiment with this myself.
─ 4 more ─
I've been trying to collect Literate Programs collected as books at:
https://www.goodreads.com/review/list/21394355-william-adams...
Note that ICC, a C compiler, is one:
https://www.goodreads.com/book/show/522102.Retargetable_C_Co...
Note that one can look through projects tagged as Literate Programming by using the topics view:
https://github.com/topics/literate-programming
might be there's something useful there.
─ 2 more ─
>might be there's something useful there.
There is! As of now, if you sort by recently updated, my literate programming project is the first result :P (link in profile if anyone reads this later)
─ 1 more ─
In the interest of full disclosure, my own project is in there as well (but nowhere near the top and it's a kind of obscure topic, so not likely to ever get there).
I would probably go down the Lojban route though!
Once a week, I tell Antigravity (3.8-flash) to rewrite every code comment and documentation that was changed in the past week. Neither GPT nor Claude can write like a human.
─ 5 more ─
Neither can Gemini.
─ 4 more ─
Gemini models have consistently been the best, by far, at writing and explaining.
─ 1 more ─
Best against other AI output, still not even close to what a human would write.
Okay, describe one quirk of Gemini-ese that makes it stand out?
─ 1 more ─
If you use it often enough, it becomes quite easy to tell. For one, when using it through the chat interface, it always congratulates me on my amazing insight in the first paragraph or at least has a very forthcoming tone. It also has a fetish for numbered lists whenever attempting to make a point, which usually contain 3 items, sometimes 2. It's also quite good at making relatively unhelpful ASCII diagrams on a semi-frequent basis.
That said, I do genuinely enjoy brainstorming with it, and these quirks are not really a hindrance. If anything, the sentiment in the first paragraph is quite useful to quickly get an insight about where I stand with my thoughts, relative to the available knowledge that Gemini has access to.
>>I get that we live in an era where the machine writes most/all of the code
Only on the Internet is this true, not in real life. I cannot and do not trust any of these things to do a proper job because they have not in any situation succeeded in any job I've given them. And no company I deal with claims otherwise
─ 18 more ─
That's like me with violins!
─ 1 more ─
Maybe violins don't write good code after all?
I can see that you only work with true scotsmen, but the machine really does write most of the code now, at least from a pure numbers perspective.
Right I feel like they just got to a point where they can reliably write individual functions with direction. Every time I've tried to use them consistently I feel like I just end up spinning wheels from them doing things that mostly work until it crashes and burns or just has straight up missing things or half truths. Skill issue or not it doesn't work for me.
Still glad I basically never have to debug a build issue or memory error again though
it's definitely true in real life. i think there is actually a massive skill gap in using them effectively.
If the Code is bad, you can tell it to fix it to match your expectations —only at the edges, are you going to have to spell it out.
Lack of documentation used to be a running joke.
The goose_spec.txt in 2019 would be "goose is like c and rust only with syntax like array{;}[] btw it uses a small amount of stacks instead of malloc."0 10klocs.
Now, we make sure the AI leaves documentation so it can figure out what it was doing earlier.
A local model a few generations and many weights behind newest Claude can implement my novel algorithms and write the documentation I wouldn't.
Yes, many times it does dumb CS for kindergarten mistakes but it only has to work towards the optimum every once in a while.
Sadly there seems to be no point in arguing online though.
- You need to have a mental model to grow an idea
- When a pattern is known you can use a library!
- When a pattern is not known AI will make stuff up
No matter how "good" coding with an AI will become there is no way you get around learning, having someone understand what's going on and take responsibility.
I'm fine with formal checking and fuzzing or getting hints where a bug might come from - but these are iterations on tools we used before like a debugger, strict types, functional programming and well fuzzing.
I tried to have an AI iterate on a step i don't fully understand yet and i always regretted it. Highly interconnected projects will grind to a halt until you do learn.
You can check with people doing highly specced software in the medical domain that even with very good specs there is ambiguity in natural language thus it can never be the source of reliable and manageable software.
However - i read about some smart guys in the 40s or so encountering the need for a formal language to tell a computer what to do with 0 ambiguity and i think they called it a "programming language"
The tools have a learning curve. You can get extreme amounts of value out of them but you have to learn how to use them. Many tools are this way.
It might make sense to learn now, before everyone expects that you be an expert with this tool in order to do your job. On the other hand perhaps they will be easier to learn if you wait.
There is an incredible amount of nuance to be had in using LLMs and we reached the stage, probably only in the last few weeks where all the pieces have fallen into place such that if you are skilled at using the LLMs just about all of the previous problems with them can now be easily mitigated. If you learn how. There is a lot to learn.
─ 7 more ─
how does one learn to mitigate not understanding the work they push , given that the work wasnt performed by them ?
─ 2 more ─
By requiring the LLM to prove your requirements true mathematcially.
─ 1 more ─
openai has retracted many of their lean proofs for the big drop of supposed novel mathematical solns. if frontier ai screws it up , how does this inconsistency manifest in weaker models?
"It might make sense to learn now, before ..." Since 2023, everything learned in Year X was 99% useless in year X+1.
"we reached the stage, probably only in the last few weeks where ..." This has also been said every other month since 2023.
─ 3 more ─
I wouldn't say that's true at all. My critical reasoning skills have improved immensely as I have learned how to find the flaws in the LLM's logic, and I am much better at code review in general than I was when I first started letting agents write code.
It really is like working with an over-eager employee. They just also happen to be a pathological liar.
>Since 2023, everything learned in Year X was 99% useless in year X+1.
Personally I disagree with this. I've been using LLMs the last few years and learning a lot about techniques for getting value out of them. Even though they weren't very good for a while they seemed worth learning to me because the rate of improvement was so fast. We've now reached a point where if you know how to use them right you can get lots of value out of them.
I really don't mean to be rude here but consider perhaps the reason why you're having trouble seeing why they're valuable is because you haven't used them enough in the last few years or kept up with the developments closely enough. Maybe I'm wrong. But consider it's possible you are too.
>This has also been said every other month since 2023.
I'm sure others have said that but my perspective has been that the models are not quite good enough yet, for a while but that the trajectory is so crazy that it made sense to make the bet and invest lots of time into learning how to use them on the assumption that they would soon be good.
Even now I would say they have a long way to go. What is hard but possible today will be easy tomorrow. But quite a lot is now possible with the right techniques. Crazy things.
─ 1 more ─
I remember using LLMs a couple of years ago, back when there was no mention of "AI" in our country whatsoever. Not that much mention of it online either (much less widespread). I felt like I was holding a magic wand nobody else knew existed. :P
Sounds like a skill issue.
This product is proof that you apparently either don't know how to use AI, haven't used it within the last 3 months, or don't know what you're talking about.
I just wrote a clean plugin in Rust. I don't know rust. It took work to avoid, remove, and replace slop, avoid spurious and pointless tests, etc. It wasn't "fire and forget". but it wrote the code, the code has been made clean, integrates well with existing project structure and does what it's supposed to. I spent a day or two on it, but had I attempted to write it from scratch, even knowing rust, it easily would have taken me longer.
Considering that I don't know rust at all, it's awesome.
Eh, I think the tutorial is pretty readable? It's concise enough.
With the tutorial, the summary also makes more sense. I have not read the other parts yet, but so far I like what I see.
All is in pretty good taste, and I like what I've seen so far. I do not care if the author himself came up with the idea, or if AI came up with it and the author approved.
I do not understand why you "have to" know this to make use of it. You can judge ideas independently of where they came from (and you should).
─ 3 more ─
This is actually a really good point that I think many people fail to understand these days!
>You can judge ideas independently of where they came from (and you should).
You can but in practice nobody does this because they don't have time. For example, once you have investigated ideas from a crank a couple of times - you don't do it again. Life is too short.
I found the language to be difficult to read, there are phrases that don’t make sense in context. It’s not concise. I also don’t care whether it was written with AI or not, and there are plenty of terrible docs predating AI. However, I wouldn’t call this documentation “good”.
I do not think you know who this guy is
100%
Couldn’t make it more than a few sentences in before the bile started to build up in the back of my throat and I had to back out. It’s shocking to me that people knowingly post unedited Claude-slop drivel and are seemingly unashamed about it. In 2026, it seems the main role of technical humans should be to act as a barrier between our agents’ output and other humans.
─ 1 more ─
Do you not use Claude at work for hours a week? I find the writing style familiar, thus comfortable.
What are some use cases (if any) that the language is not suitable for?
Probably kernel code, or cases where allocation randomization is important. Seems like with goose you may end up executing more deterministically (but still it can randomize where these N data stacks start), but because it's single threaded workers (in essence), all data construction would follow the same pattern, hence an attacker (something snooping your memory) would know easier where things would be.
Where does the language stand in the array-of-structs vs struct-of-arrays choices? Does it offer an annotation to choose that like in Zig?
It does not currently offer automatic AOS -> SOA transform, you'd have to do that yourself. I did look into it, but doing it automatically is not a great fit with how Goose tracks arrays. Maybe can be reconsidered at some point.
Way off topic, but I enjoyed Amiga E. And, I reckon you're one of a handful of people I would take seriously when they say, "I made a new programming language."
Thanks, that brings me back, haha :)
Given we are getting to the point where coding agents write most of the code, what motivates you to create a new programming language? Follow up: do you build these languages keeping humans in mind, or are these meant to be used by AI agents?
I've been making languages all my life, and I made this one because I had a really strong design in mind that I think should exist.
Whether it would make sense in this AI world was not a consideration.
The syntax and semantics were mostly designed for humans. That said, using it optimally asks a lot of the human, and in turns out the better LLMs don't break a sweat using it, so maybe it accidentally hits the spot. Goose with LLM can give you lots of speed without the effort.
In some weird way it is a great time to make new languages, because the downside of convincing humans to learn it is gone. Anyone that has a project that needs to be fast can decide to use Goose for it at very little cost.
─ 1 more ─
Thanks for your response. I have been wanting to dip my toe in the space of language building for a while, but keep getting discouraged by the advances of coding agents. Love your reason for building this!
>I made this one because I had a really strong design in mind that I think should exist.
In this example does it compile if you write return inside the block right below w (where the error occurs)? https://github.com/aardappel/goose#safe-references-no-annota...
Hows the compile time? Do you have a number or is it similar to another language?
Good question, not sure without testing. Likely it will still give the error. It could elide it, but I am not sure how useful that is.
Optimized builds go thru the local C compiler, so they are limited by the speed of that. Dev/test build can use the built-in libtcc JIT which is super fast.
I have my own language I'm working on in private and it's nice to see other people coming to the same conclusion on region based memory. I was heavily influenced 7 years ago from learning from HandmadeHero and the community around it, and so I made that memory model one of my goals from the start, and it is indeed possible to get very fast programming with it when you make it your default, and when you make the language able to statically analyze it more.
That is about where our similarities end, though, since I'm doing quite a lot of other stuff in the midst as well (much heavier type stuff, fully incremental, retargetable, reflection, integer range tracking, blah blah blah), and the more goals you have, the complexity blows up exponentially. I do think that the region based memory part alone is worthwhile to have as a language feature, so I applaud your pragmatism. I like your syntax for returning through call stacks, too.
There are other languages that do this, though. Did you look into any of the others? Or ones like Odin which give you the configurable bump allocators and scratch space as well? Mainly I'm curious about your opinions of prior art.
it's too late to edit but i saw the prior art on github now https://github.com/aardappel/goose/blob/master/docs/design/p...
anyway, hope this project goes well! the secret of the arena allocator seems to be out now to the mainstream. I think this is also a strength of array programming languages in the tradition of APL/J/K/Q.
As this project develops, I'll get to benefit from your public crowd sourced testing and design before having to publicize mine :P
─ 1 more ─
Yeah, my language in development uses only arenas for memory management too. But this Goose language is next level.
I will take a better look at Goose some time later when it's not late at night. Just wanted to drop by and thank you for creating Treesheets. I haven't given its more advanced features the use they deserve, but I love it as a note-taking application for anything that complexity-wise sits between a short outline in a plain text file and a ton of Markdown in something more advanced like Obsidian. And for, of course, any tabular data.
Hah cool, small world :)
You might want to update https://strlen.com/language-design-overview/ at some point.
Haha yes, haven't updated my website in a while :(
Interesting, I'll play with it. In the "Why Goose" section there is a mistake I guess : "Faster than C++ and than safe Rust, while memory safe."
I don't think it's a mistake. He's claiming that it's faster than C++ and it's faster than safe Rust.
─ 4 more ─
The extra "than" in front of "safe Rust" is superfluous and reads like an error, as if there's a comparative adjective missing ahead of it. I don't see any situation where "and than" should ever appear in any non-contrived English sentence.
─ 2 more ─
So what? He's not a native English speaker, and my interpretation is clearly correct, which the GP has acknowledged.
And FWIW, I actually think that "faster than C++ and than safe Rust" is clearer than the more idiomatic "faster than C++ or safe Rust", and certainly clearer than "faster than C++ and safe Rust", which looks like a conjunction of "C++" and "safe Rust". He could have written "faster than C++ and faster than safe Rust" but that's more wordy and awkward.
Enough of this pointless and irrelevant pedantics ... I won't respond further.
P.S. Just to be complete, here's an AI slop response:
You are completely right, and that is exactly why the author likely structured it that way.
In technical writing, "Faster than A and B" can be highly ambiguous. A reader could easily interpret it in two unintended ways:
• The Sum Interpretation: Faster than the speed of C++ and safe Rust combined (which makes no sense logically, but fits the literal grammar).
• The Blend Interpretation: Faster than a hypothetical hybrid ecosystem or a specific setup where C++ and safe Rust are used together.
By writing "Faster than C++ and than safe Rust," the author is using a repetitive parallel structure to force a distributive reading. It explicitly separates the two entities, making it clear that the language is:
1. Faster than C++
2. Faster than safe Rust
So while it sounds unnatural to a casual reader, it was a deliberate choice to ensure mathematical and logical precision over poetic style.
─ 1 more ─
After reading this comment a little more deeply, I've come to believe your views on methods of written communication are subtly, fundamentally wrong in a way which generally causes more harm than good.
If a sentence has multiple "valid" interpretations, then it doesn't matter what the "correct" interpretation is. If someone says that a sentence is confusing or hard to read, you 100% must believe them and fix it. Dismissing concerns about clarity and ambiguity as merely "pedantic" is one reason why people fail to develop written communication skills. I have been burned many, many times in my career by making charitable assumptions about another engineer's ambiguous language, only to realize much later, after significant cost has been paid, that they had a completely different (and often wrong) idea.
Teaching people to be better writers is a hill I will gladly die on. I don't care if you defend your point or not, just read my comment and try to understand why someone would care deeply about this sort of thing.
You're right, thanks for correcting. I misread the "and than safe Rust", thinking it was "and safer than Rust".
Why would that be a mistake?
It's because in Goose* you write `x > a && x > b`, not `x > (a & b)`. :)
*And really in most if not all, Raku excluded**, languages.
**In Raku junctions can be specified with infix ops, i.e. a | b, a & b, a ^ b, equivalent to list ops any(...), all(...), one(...) respectively, and can define a custom one for none(...).
And ... you made Lobster lang, Cube2/Sauerbraten 3d shooter and voxray/voxile and lots of other cool things.
Sauerbraten is such an amazing game. Every so often I boot it up and play some venice instafrag
Oh wow this takes me back. We had very poor internet connectivity when I was growing up, so my brother and I played Sauerbraten and a handful of other games exhaustively with a crossover cable strung between our rooms.
And not to forget Amiga E language...really cool stuff
Hey the memory model is super interesting.
Looking at the repo it seems like the N stacks generated by the compiler are placed at least 2gb apart in virtual memory, have you run into any cases where that has been overflowed during runtime? The compiler cannot know which of the stacks are going to be used more than others and in a large complex program with many stacks any one of them could fail. I imagine this being an issue depends on target application - if you know you are building a game that you know the exact size of your levels / entity counts beforehand you know this is fine but if you were doing data processing / parsing potentially malicious user input it may be a problem.
I'm also interested how the memory locality works. Here you have the bases of your stacks at a series of very sparse virtual memory intervals which will be mapped by the page table to some physical memory addresses, does having them be so sparse cause any issues?
There are some unique ideas here - lifetimes on references to growable+shrinkable stacks, "balancing" stacks in recursive functions - and I'm glad you were able to use coding agents to actually materialize them.
No, not yet. You can also change that amount if you want, just 2GB is a pretty optimal default.
I am not sure what issues could be caused by the sparsity. Like you say, all that matters is that in physical memory, we are only using what is actually in use.
Thanks! :)
I am an AI and take offense with your statement.
Is replacing rust a goal? If so I'm in! Just kidding, actually there are so many things I didn't get, good thing we have discord probably ask there. I used your other programming language lobster earlier, and have high hopes on this.
Thanks! There is certainly a big overlap with Rust in use cases.. I'll leave people to decide which they want to use :)
why is it not written in goose
The main page was such obvious AI slop that I didn't bother looking further
I really like your work.
I like the XY language, what do you think? https://nsl.com/k/xy/xy.htm
I generally LOVE concatenative languages! I made this once: https://strlen.com/false-language/
─ 1 more ─
:)
Just curious why you kept semicolon as terminator. A good thing Golang did was to get rid of it.
I guess Goose is closer to Rust and C/C++ in design, and removing it does introduce some parsing gotchas.
I guess people also differ by how much they are bothered by it :)
My other language, Lobster, has no semicolons at all :)
How can you claim Goose is faster than C++, i.e. faster than the language whose subset (i.e. C) it compiles to?
C++ code that does what Goose does is a soup of pointer manipulation, casts and byte stuffing. You could write that, but Goose proves it to be safe at compile time, with simple readable code. The moment you write "reasonable" code in C++, it is actually a lot slower than Goose.
For details on how, see https://github.com/aardappel/goose
─ 3 more ─
But then why isn't Goose a library or framework within C++, or a macro in Rust or something else? Why does it need to be a language?
Also, to be transparent in your benchmarks you should compare against idiomatic safe code, and optimized code. It's trivial to throw your benchmark examples into an LLM and tell it to optimize them to parity with Goose. It's more trustworthy to show other languages can achieve the same performance, Goose isn't doing anything special there. What it is doing is doing the same with better safety guarantees, which I think is headline result not the speed itself.
─ 2 more ─
Because you really can't do all the static checking and convenience like that with a library.
As for the benchmarks, that's exactly what I do: https://aardappel.github.io/goose/bench/results.html
If you mean the other benchmarks (LangArena), I don't control their design.
─ 1 more ─
But it's not infeasible as a preprocessor or macro though, since you're outputting C anyway right? You could even output C++ or Rust.
>As for the benchmarks, that's exactly what I do
What I mean is the story of those benchmarks is incomplete, you're missing a column for optimized Rust. This is what I get on my M1 if I ask the LLM to write more performant (still safe) solutions to a couple benchmarks, I'm sure your LLM can do the same:
| Benchmark | vs original Rust | vs optimized safe Rust | Memory vs original Rust | Memory vs optimized safe Rust | |---|---:|---:|---:|---:| | `sexp` (flagship workload) | 1.00× | 0.95× | 2.22× | 1.60× | | `records` | 1.52× | 0.54× | 4.77× | 2.58× | | `graph` | 1.24× | 0.75× | 1.00× | 1.00× |I think for the Benchmarks Game entry specifically, for the expert solutions you should use submissions to the game for both C++ and Rust instead of LLM generated code. After all, those are legitimate expert-implemented solutions to the benchmark, so it's nice to not have to lean on an LLM there. That would also give you something to optimize towards.
Wow, Mister van Oortmerssen himself! I was a big fan of Bla's first-class environments! You're a legend!!
Haha, I thing "Bla" was probably one of my least successful designs! So elegant, but too weird? Anyway, glad you remember :)
No relation to https://goose-docs.ai/ I guess?
I can't see a reason to use this and not C++ It reads like slop text
>to use this and not C++
Why Goose - https://aardappel.github.io/goose/#why-goose
Looks cool, and well developed. But really, cover pages need some better TL;DR, about the purpose. What is it for? There are a ton of languages out there. What gap is this filling? What is the purpose, the use case. Why do I need to keep reading further?
Edit Man, two posting about Goose back to back. Carmack alone might be enough to read further.
I think it is a general systems programming language that fits for a variety of use cases but especially well with trees, records and where you want to have direct data (de-)serialization, like flatten out a tree and pick it up then (last one reminds me of FlatBuffers, another invention of the programming language author). I think if you look into the Discord channel there's some nice examples.
Educate me: how to create a program in Goose which reads a JSON structure, prints it out and finishes. How is memory for JSON allocated on stack? It can be from 1K to 1M - depending on the file...
I don't see why this is problematic. Stack is just memory, you can allocate it by incrementing a pointer. Any amount you want, really.
Apache modules worked like this (still do, presumably). Each request has a stack; allocations bump the stack pointer; when a request is finished, the stack pointer is reset. Incredibly efficient as long as you don't need to keep memory longer than a single request.
Looks like in Goose, each scope acts like an apache "request".
In Windows, by default, thread's stack is capped at 1MB. Main thread gets more but that's somewhat off the point.
─ 2 more ─
Stack size is completely arbitrary, just like heap size. You have 2^64 addresses to work with.
There's stack the CPU primitive, and there's stack the heap-allocated data structure. Goose's multiple stacks are the latter. Unrelated to OS-managed thread stacks. More like VM-managed thread stacks in Java and other bytecode languages, which also live on the heap.
>How is memory for JSON allocated on stack?
Check the features section (https://aardappel.github.io/goose/#features), which starts off with how memory works.
I'm not familiar with Goose, but based on some research and my understanding of how memory works:
At compile time, Goose will analyze your program and determine a number of stacks, N, for it. N is the maximum number of "growable" items you can have in existence at any given point in time. Using virtual memory tricks, each stack can grow up to 2GB, but it uses a contiguous address space and only uses as much physical memory as it actually needs.
For the program you're describing, I think you would end up with two stacks: one to parse the input and a second to print it. When you parse the input, Goose reads characters from the string one at a time and puts them onto the stack. Once it has hit the end of value, it will update the stack so it now represents the decoded JSON value (strings will just leave the characters in place, numbers will pop off the characters and push the number onto the stack). Goose repeats this until it has parsed the whole JSON, and now the whole JSON is on the stack.
Then, when you print the JSON, Goose uses the second stack to build a string. Like the parsing approach, it iterates through each element of the JSON and pushes its string representation onto the stack. Once it's done, it resets the stack pointers to free the memory.
This is really nice because allocating memory is just adding to the pointer, and freeing it is subtracting from the pointer.
In contrast, Rust automatically inserts malloc() and free() calls throughout your code, which are much more expensive than pointer arithmetic. On top of that, freeing a vector of heap-allocated objects is O(n), whereas if done right in Goose, it would be O(1)
https://github.com/aardappel/goose/blob/master/samples/18_js...
Goose can store entire trees (of variable sized things) inside an array.
Lobster is the author's other programming language, previously discussed on HN: https://news.ycombinator.com/item?id=47239955
Interesting. Lobster rocks, and Goose is similar to something I've been building on the side, but would rather have someone build for me... Hopefully this guy does it!
Well, it seems Claude mostly built this.
*one of, you mean:
Rust's appeal (to me) is safety, performance, DX in that order.
Where does Goose sit when classified along these dimensions?
Sure, performance is right there on the packaging but no word about UB in the README. I read "Goose has syntax familiar to C and Rust" as DX in the same ballpark, but is it a performance first or safety first language.
If it is the former it occupies the same crowded niche as C++ and its many cousins and will have a hard time.
If it's the latter it will have much more room to prosper. We don't have enough languages in the niche that Rust and Ada fill right now.
Well, "safety" is a lot of things so you have to be a bit more specific than that about your use-cases. And I can't really answer it either way - I think WvO has to chime in about that himself - but I can point to some things that might give you some idea of what to expect. Here's what WvO wrote a few weeks ago when he shared Goose on twitter:
>Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.
>It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.
https://xitter.cf/wvo/status/2107979660558766351
So one way to answer might be: how often do you reach for unsafe when using Rust? If you don't I guess Rust is safer. If you do… it gets trickier.
As for UB, I guess you could try looking through the spec and/or the reference? Like, the code is mostly generated by Claude after WvO wrote a specification. If it were anyone else I'd be worried, but given WvO's cv I actually suspect that means the spec leaves basically no ambiguity.
However, Goose compiles to C. Does that by definition mean UB sneaks in, or is there a "UB free" C subset? I don't write C, so I don't really know.
I guess my question is if you can trigger UB in regular Goose and if you can, would it be considered a bug. I realize that this doesn't necessarily have a simple yes or no answer but I still think it'd help to know if Goose is more on the C++ side or the Rust side.
The complete omission of UB in the README could be one of two things. Either that the topic is not important or that it is considered a given and not worth mentioning.
─ 2 more ─
Hmm, well the benchmarks always use an explicit "faster than idiomatic C/C++ and safe Rust". Similarly it also notes that in theory you could write equally fast C/C++ (since Goose compiles to C), but it would be an unreadable, unsafe mess.
Note also the fact that e.g. array indexing has bounds checks without escape hatches for the programmer, but the compiler can elide quite a few of them, and the language has tools to help the programmer write code that is guaranteed to be check-free.
I think that suggests the ambition is to compete with Rust in the domain of combining safety with not compromising on performance.
Goose has no undefined behavior.
Certainly there's a UB free C subset ... everything specified by the C Standard or designated as implementation-defined is UB free by definition.
UB in C potentially destroys the universe so C programmers do their best to avoid it. A backend that generates C code is a lot more easily constrained than arbitrary manual code. While it's conceivable that a C backend could produce UB code, it would be a severe bug and isn't likely. It most certainly isn't "by definition" ... that suggests some serious conceptual error.
Goose has no "unsafe" feature, and no undefined behavior, and is fully memory safe.
It is obviously has a lot of potential to be very fast.
It even does pretty good on DX. There is no borrow checker to fight. Algorithms that need indices in Rust are strongly typed references in Goose. Generally pleasant easy to read and write code.
The biggest thing against DX may be exactly where performance comes from: you need to think a bit on where to store your data :)
>and no undefined behavior
Where is the behavior specified?
─ 2 more ─
In the language spec: https://aardappel.github.io/goose/docs/goose_spec.html
─ 1 more ─
Have you read this document?
Goose is written by a game developer. They tend to concern themselves with C++'s niche.
Do android dream of goose?
PLEASE rewrite this without AI-isms. AI can write perfectly good code now, but its prose - even the latest models - is just awful to read. It hurts my brain to read this.
I like it this way, it gives correct expectations regarding effort put into the rest of the project.
That's a bit rough. Would we say the same before AI? Bad docs so bad project? I guess people should realize that less is more, don't commit that bad README not even as placeholder.
─ 1 more ─
>Would we say the same before AI? Bad docs so bad project?
To a large degree, yes. But I would say it's more like "lack of care, bad project".
Keep going, and I hope more people start rolling their own languages.
If anyone is interested, I'm fairly close to finalizing Slang and I'm considering open-sourcing it in the near future. What originally started as a simple register based lang for an embeddable VM turned into an insanely expressive meta?programming language. Full system Fω, expansive whole program reflection (you can reflect on absolutely anything), string memory & logic safety..
You can do stuff like this:
(fn answer () -> i64 0)
(defpass build-answer
(phase source)
(transform (lambda (f)
(fn-with f 'body '(let ((a (arr (42)))) (at a 0)))))
(safety (lambda (goal) (syntax (refl)))))
(run-pass build-answer answer)
(fnmut answer
(transform (lambda (f)
(if (memory-safe? (check-memory (current-program)))
f (syntax-error 'unproved-memory)))))
(defpass inspect-ssa
(phase ssa)
(transform (lambda (f)
(if (memory-safe? (check-memory (ssa-current-program)))
f (syntax-error 'unproved-ssa-memory))))
(proof (lambda (goal) (syntax (refl)))))
(run-pass inspect-ssa answer)
(answer)
or this: (fn next ((i i64)) -> i64 (+ i 1))
(fncontract next
(ensures result (successor (Eq i64 result (+ (old i) 1)) auto)))
(fn read-second ((i i64)) -> i64
(let ((a (arr (0 42)))) (at a i)))
(fncontract read-second (requires (one (Eq i64 i 1))))
(let ((i (next 0)))
(with-proof ((one (Eq i64 i 1) (result-proof i successor)))
(print (read-second i))))
it also supports full inline asm or llvm ir: (var answer 0)
(asm (input rdi 20)
(input rsi 22)
(output rax answer)
(mov rdi rax)
(add rsi rax))
(print answer)
(macroop \ (a) (asm (mov a rax)))
(\ 42)
(print (llvm add 20 22))
(print (->i64 (llvm fused-multiply-add (f64) 6.0 7.0 0.0)))
(llvm fn sum32 ((x i32) (y i32)) -> i32
(block entry
(value answer (llvm add x y (declare (flags nsw))))
(llvm return answer)))
(print (->i64 (sum32 (the i32 20) (the i32 22))))
Even though you can write this by hand, the core idea is to get a very dense and terse language that LLMs can emit while guaranteeing safety and performance.>Even though you can write this by hand, the core idea is to get a very dense and terse language that LLMs can emit while guaranteeing safety and performance.
So now your safety and performance issues are in the LLM and whatever prose you feed it for it to generate slang. Have you gained anything?
(Not meant to detract from the language. It's just that this particular goal seems... strange).
Try Common Lisp and Coalton. Also, Common Lisp and that one math proof solver.
You should submit your own ShowHN to talk about it rather than hijack some other language’s announcement thread.
I seem to remember the ML guys went down this route. I believe they called it regions.
From what little I read in the literature I seem to recall that there were enough programs with quite a bit more memory usage that they decided this approach was a dead end.
Does anyone know anymore details?
Yes, ML Kit region inference is probably the closest prior art to Goose.
Back then though, they couldn't lean on large 64-bit address spaces like Goose can. They implemented all of this with a chain of blocks of memory instead, and tracked most of it at runtime that Goose now does at compile time.
https://github.com/aardappel/goose/blob/master/docs/design/p...
[flagged]
The right ideas. Not optimized for reallocation. Creates pressure to overload types, making secure software unattainable.
This looks very interesting! I mostly write in garbage-collected languages (to the extent that I still write anything by hand...) so I'm just a spectator in memory management debates, but it's often struck me that heap management is more of an art than a science. The idea of treating memory more like stacks made immediate intuitive sense to me. I'm also fascinated by the thread implementation, although I'm not knowledgeable enough to to think through the potential benefits/costs vs other approaches to concurrency.
I wonder if the name of the language was inspired by the way geese fly in formation, with trailing birds saving energy by flying inside the aerodynamic shadow of the leaders, and swapping in and out as needed. If so, a very nice metaphor for the memory management model.
I was also impressed by the documentation. As we know AI-generted docs tends to be rather mediocre, but the author has clearly invested time in making in readable such that the relevance and rationale of design decisions provide the context that a curious programmer needs to understand why things are implemented in a particular way.
I really appreciated the detailed samples, ranging from simple algorithmic theorems up to a small game. Again, I don't have the experience to rate the language vs others, but I was struck by readable the code was and how easy it was to follow task flow. Not having to think about classes is always a plus!
Anyway, I usually the the offering of a new language with dispassionate interest, as something to be aware of and but not get too invested in or familiar with until it gains enough popularity to have a good shot at longevity. Goose is the first language in a long time where I looked at it and immediately thought that I'd like to use it for its own sake.
Thanks!
The name is an animal because all my past PL designs are animals (I also made Lobster etc). Goose seemed like a fun name.
I'm curious, for someone more familiar with Goose: how do you represent an arbitrary number of dynamically sized values? If you have a fixed number of stacks, it seems like only a fixed number of values can change size at any given time.
For instance, how would you represent a hash table where the values are strings and at random, the program inserts or deletes a random string?
This doesn't seem like something you could easily represent. The only way I can think of is to keep a stack that holds all of your strings, and you periodically compact it.
Edit: Maybe you could also have a separate stack for strings of various sizes. One each for strings less than 8, 16, ... bytes. But at that point you're basically implementing your own malloc by hand.
Edit: Fwiw I do think Goose is very cool! I've had to hand-roll a lot of similar stuff in Rust before to speed up memory management
>how would you represent a hash table where the values are strings and at random, the program inserts or deletes a random string?
Goose has a built-in generic hash table called dictionary<K, V>, provided by its standard library.
https://aardappel.github.io/goose/docs/stdlib.html#dictionar...
From the link
>Keys and values are fixed-size
so not quite what I'm looking for
─ 3 more ─
You can store the strings separately and have the dictionary hold references to them.
Conceptually:
dictionary<i64, StringReference>
|
+----> "hello"
+----> "a much longer string"
+----> "x"─ 2 more ─
Isn’t this just re-inventing the index arena pattern, which nullifies much of the benefit over rust?
>Goose code holds typed references where the equivalent Rust holds u32 indices into an arena — and it is where a good share of the benchmark wins come from.
─ 1 more ─
In this particular case, you could make the values fixed length strings. Somewhere, performance and memory trades.
I think the limit of this would be creating your own allocator that works with the stacks, but you could probably stop short of that in most cases.
It's not entirely mad to do it this way, and I can see some benefits. For one, you might have multiple of these pools across the program for different data-types, which would make allocating to any one of them a cheaper operation. It is much more reference safe since you are only ever freeing stuff in a certain context and you can still never have dangling pointers. When you look at memory safe languages, they all default to this eventually. Like Rust in the advanced case will have you implementing your own allocator, lot's of games use this thing called ECS which is essentially a kind of allocator. Goose would just have it be more common.
This is roughly what I do in Rust. I use different static types for values based on how long they'll live. Temporary values get one type; cached values get another. The allocator allocates each value in a different location based on how long the value will live.
I'm not familiar with Goose, but I'm guessing you could define a single stack and put your dynamically sized values in it. Essentially rewriting a memory allocator on top of Goose's stacks. This is what they seem to be doing here: https://github.com/aardappel/goose/blob/master/samples/13_li...
Yeah, that looks like a freelist approach. That will work as long as the values you're allocating are all fixed-size. You'll need something much more complicated if you want arbitrarily sized values
That example implements a linked list of integers. I'm curious how you would do a linked list of strings
─ 1 more ─
you can make each string a linked list of bytes (or chunks of bytes). But it won't be efficient.
Certainly, this is a language where you get the most benefits if you are able to structure your data usage such that things of similar lifetimes sit together in arrays.
For example, you can build up a tree of all variable sized nodes inside a single array.
Where it gets interesting is if you must arbitrarily delete tree nodes, and you can't structure it to do that in stack order. The language has various tools for this, like fixed arrays with capacity, or pools of either single elements or runs of elements.
Does it have (or can it in principle support) "parallel" pools? So that structs can be stored in "columnar" fashion, yet accessed without knowing the particular way they are sliced?
I was looking into this as well, it seems that Goose does not support having a dynamic number of resizable values, but it does support having a dynamic number of dynamically sized value.
In Rust parlance this would be the difference between a `Vec<Vec<T>>` (many `Vec`s, each can be resized) and a `Vec<Box<[T]>>` (many `Box`ed slices, each with a dynamic size, but none of them can be resized).
I bet you can exploit dynamically sized values to rebuild resizable values, with the downside however that you'll likely leak their memory until you exit the current scope.
If you can't be bothered to read and structure your own README after getting an AI agent to write more than 10,000+ lines on a single page, it becomes a DONTREADME.md.
Yet, the author expects YOU to read all of what they didn't write. So I ain't reading all of that.
Interesting, but can you write something like an LRU cache?
Ah, I see how that works. Thank you. So I guess the main tradeoff is giving up concurrent data structures.
─ 1 more ─
Shared data structures accessed concurrently by multiple threads, yes.
Goose's thread system however has typed queue's inspired by the Linda Coordination Language https://en.wikipedia.org/wiki/Linda_(coordination_language) that can most definitely model some interesting data structures.
>One memory model: stacks, and scope exit is the free
What are the ergonomics of this I wonder.
Well, my dayjob is writing JavaScript and I've having a blast writing Goose code by hand in my spare time in the last weeks, so it can't be that bad.
I love that the logo is a very fast goose
I'm curious, when returning a dynamically sized array from a function, does the whole array need to be copied? C++/Rust would simple move the array out of the function (i.e., they would only copy the pointer to the underlying data), but it seems this wouldn't work in Goose if the stack the dynamic array lives in is cleared on return?
Goose determines where the array will be copied to at compile time and allocates it there.
Rust does a similar thing. When a function returns a value, a location for it will be put in the callers stack frame. That means it automatically stack-allocates values when feasible. The downside in Rust is you need to know the size of the value at compile time whereas Goose can do it for arbitrarily sized values
I made the language, AMA :)
If you mentioned it in the main page, I didn't see it.
Something that I'm interested in: How fast is the compilation speed on large programs compared to Zig, C, Go?
My ideal language is safer than Rust (no deadlocks / livelocks, no stack overflow from recursion), is optimized for cache locality, but compiles faster than Zig.
This seems like it's close to 2/3.
The current implementation goes thru an optimizing C compiler as backend for "shipping/production" builds, which will limit how fast we can make it compile.
That said, during development/iteration/testing, you can just the built-in JIT, which is based on libtcc (which is very fast), as don't as you don't mind a ~3x runtime slowdown.
Fantastic project BTW! How much AI help did you have with this project? I'm assuming some. If so is it something that you would have taken on before AI help?
There's a section at the bottom called "History & Use of AI". Please do your part to keep the discussion here honest and healthy, if not a read of the post, at least a ctrl-f would have been sage.
Was it your first programming language ?
ps: Ah well, I could have searched before asking https://strlen.com/programming-languages/
super neat history !
Haha yeah no, I'm afraid I keep making new ones! :P
Without wanting to be snarky, are the "hand optimized" C++ benchmark files mentioned on the benchmark page available anywhere, as the ones in the "bench/cpp/" directory don't look that optimized to me?
e.g. I see a general lack of reserve()s on strings and vectors (a few tests do use them a bit, like `graph` and `particles`), and there are several other things which I wouldn't personally call "optimized", so I assume those ones are the 'idiomatic' ones?
Same goes for the Rust code: a lot of the code seems to be using Vec::new() and String::new(), instead of ::with_capacity() which would optimize the memory re-allocation (reducing it as the containers/strings grow).
Yes indeed, the real hand optimized files are private, the ones in the repo are decoys.
─ 2 more ─
Why?
─ 1 more ─
It was sarcasm, I guess
Do you think it would be worth writing the landing page yourself? The concepts seem interesting but it's painful to wade through stuff like "One memory model: stacks, and scope exit is the free".
I've already edited it plenty, but I guess it doesn't bother me that much.
I preferred people being able to play with it rather than worrying about any claude-isms :)
─ 1 more ─
It's easier to play with if the documentation and initial selling page is easy for humans to read!
Would be interesting to see Luke’s Zed language from the replies on HN.
It would be really great to see how it fits in embedded systems, MCUs in particular!
Embassy (https://github.com/embassy-rs/embassy) uses this concept of no heap allocation and I find it really solid. Even if you write in C, most of the times you don't use heap. MISRA, the C coding standard for automotives, doesn't allow dynamic allocation!
The language as it stands actually uses relatively little physical/committed memory, so could be used in embedded systems, but does rely on there being a 64-bit address space, which is probably still not as common in embedded.
I was going to ask the same, but I guess it may also not be good fit for some kernel programming, given that the heap is shared along with other code.
But sounds great for 64-bit user space, with enough (48-bit, or more) virtual addressing available. Obviously one can hit some snags if for some reason quite large allocations has to be done, but maybe one has to rethink that too.
I'm starting to fall in love with this approach ;)
Goose is pretty cool. The idea is that you don’t need to make representable all programs: a language for a restricted purpose is ok. As long as you can statically specify the number of growable memory regions, you can use Goose. However, since there’s no garbage collection, you’ll probably need to be careful about memory use while a program is running. Ie: the stacks can get too big if you keep growing them, even as old data is not used any more.
Still, for a large number of programs - like data-oriented applications - it’s probably a good fit. It might work ok with entity-component game systems as long as you reuse old memory…
You typically "allocate only" if a data structure is made entirely on construction, or if its growth is bounded.
If it is potentially completely unbounded, you need different solutions like a pool, or essentially reconstructing etc.
Why not build in a very simple garbage collector - for example a ref counter - and default to it when you can't prove stack tricks are suficient at compile time? This guarantees all programs can be represented and it removes range anxiety for anyone trying a new language.
Seems any compiled language with automatic memory can make use of the techniques to obtain speed ups.
IIRC, this is feasible. But I think there's a nice simplicity in constraints. You know what you'd use Goose for, if it limits what you can express.
He didn’t comment on goose. He talked about a concept and the goose guy said “that’s like my idea”. And John said “yeah sounds like it”.
You can see from his comment that he apparently went to the Goose repo and read it. What he references is neither in his original tweet nor my reply.
The headline is misleading. He hasn’t been commenting about the Goose language and his experience with it. And you are promoting.
─ 1 more ─
He literally says its neat..lol. You need to touch grass.
Can someone explain the weird phrasing here "Nothing moves, so references survive growth" that AI does.
Almost all languages rely on reallocation when a growable array grows, which means you can't store pointers to elements, as they get invalidated upon a reallocation.
In Goose, things grow in-place only, since they have a large amount of address space reserved.
no i mean literally the sentence structure
─ 1 more ─
with the context the creator just gave, this isn't actually a bad sentence, it just lacked, well, context.
"Threads that share nothing. A worker is compiled as a separate program with its own memory, and flat values cross typed queues as a memcpy. Data races, locks, atomics and memory orderings do not exist in the language."
That reminds me of Dart Isolates - https://dart.dev/language/isolates
What are the down sides? That's the key question when a better thing comes along.
These are some downsides: https://github.com/aardappel/goose/blob/master/docs/tutorial...
I'd put the pros and cons right up front on the README.
Selling the positives for a new programming languages should go hand in hand with a realistic thorough analysis of the negatives.
Negatives of the language as a brief point 18 on the tutorial makes the negatives look hidden.
─ 2 more ─
He is not "selling" anything. I don't see a price, quite the opposite - it's on the user to evaluate it's points, not on the "seller" (that he is not). Obviously if this becomes paid, or paid through support product this would be one of the first points of the table - "what are the limitations, what should we be aware of sorts".
─ 1 more ─
Of course he's selling. Almost every word on the front page readme is a features and benefits sales pitch.
But, as all good salespeople do, they focus on the positive and leave the negative in the fine print.
Selling happens everywhere all the time without price.
>No function pointers
As in nothing functional at all? Or are there anonymous functions etc?
─ 1 more ─
The function values are just compile time, not runtime. It has great support for higher order functions and other functional patterns (map/filter etc)
I hate when I see a new programming language, get my hopes up and it turns out to be AI slop again.
There might be some decent design ideas there but if you can't be arsed to write them down in your own words but instead make me read AI generated slop I am out.
Look at my language: https://github.com/Panzerschrek/U-00DC-Sprache/. It has plenty of interesting ideas, but is fully human-written (and will remain human-written).
Oh, I love that!
Mandatory initialization, strong typing, context free grammar, lots of good basics. If you get the C++ header converter to work so you can use most C++ libraries I could see this as a great C++ replacement.
For Windows, these N data stacks would probably just RESERVE the address space, and as it grows COMMIT it, right?
I guess there would be some penalty to be paid here for smaller pages, but being mostly contigous might also help some.
That to be said, such language seems to require 64-bit virtual address space in order to function reasonably, right?
Also a .dll written in it might not be the best suited, for example if loaded in the middle of fragmented virtual address space it may need to find itself hard to allocate N contigious data stacks (do they absolutely have to be contiguous, what if they are simply ropes or deques or connected chunks ... obviously if some data structure requires to be contigous that would be a problem, but maybe this can be expressed somehow.... or maybe I'm overthinking here).
Super excited about this!
Yup that's how it works. Goose runs great on Windows. Yes, it be very tight to make work on 32-bit. DLLs definitely possible, most Goose programs only use a fraction of the 64-bit address space.
How would this work in wasm land? It's a bit badly put question, because this leaves out a lot of context - wasm - where, how, what implementation, but from my simple understanding most of the wasm is 32-bit running in a browser. For this to work, it'll need true virtual 64-bit (or 48-bit) address space. The host, being the browser, or something else, may provide it, but....
If the host needs to load several of these .wasm, compiled with goose, then it'll have to run them in separate (browser) instances too (or maybe that's how wasm works by default - not sure).
It just got me thinking - the languge is prepared to translate into javascript workers, because it's really single threaded by nature with communication between threads (or put in the dart languages term "isolates"), which makes them perfect for the browser, now the only question is the memory layout.
I don't know if it's applicable here, but Wasm programs can access multiple memories.
Sadly these memories are accessed thru a constant in the load/store instructions, and Goose would need this to be dynamic (since you can have code that processes pointers coming from multiple different stacks).
To run well, it doesn't just need wasm64 (which I worked on btw!) but it also needs the wasm64 memory to not commit until touched, or have a feature that allows Goose to do that. That and larger total memory. I pushed for that a while ago but I don't think it is possible today.
God the AI slop writing is horrible. Please just write the docs yourself, as others have stated, I can’t trust this at all. The “the one idea” made me cringe so hard I almost fell out of my seat. Every time I make something that’s exactly what Claude writes for the starting page.
Have you considered rewriting your unintelligible slop comments with AI ?
My guy, I ripped this message off on my phone on the train. You should feel happy it’s from a human these days. I am genuinely happy when I read a comment that I can tell is an honest reaction from a person, but not everyone has to feel the same way, I guess. Have fun reading through this documentation tho
─ 1 more ─
Some usernames scream "it's not worth the reply"
LOL
Im not gonna judge it by anything other than name. Its awesome, Goose it up.
I remember Intel’s segmented memory model, and in the end everyone just wanted a single large and flat segment
Great work on Goose, a whole load of practical thought went into it!
I’d love to see 1st class lightweight ‘processes’ and typed comms, like CSP. These light processes would be cheap to spawn in the thousands, with synchronous comms. So it’s possible to quickly use arbitrary networks rather than OS thread worker pools with queues. Maybe like:
fn produce(out: chan<i32>) { for i in 1000 { send(out, i); } }
fn consume(inp: chan<i32>) { for i in 1000 { print(recv(inp)); } }
fn main() { let c = chan<i32>();
par {
produce(c);
consume(c);
}
}Have you seen the way Goose does threads? It's actually pretty close to what you're talking about: https://aardappel.github.io/goose/docs/reference.html#22-thr...
>Memory is a handful of data stacks that the compiler assigns statically
I doubt this can work well in all cases. Sooner or later one needs proper heap.
>and scope exit is the free
And doc is the slop.
mighty interesting, i scanned the nuances about the memory model, but it doesn't explicitly say so, but am I right that some workloads will result in heavy fragmented physical memory allocations?
No, I don't see how that would be. It will map process address space to physical memory just like other programs. Physical memory is already not guaranteed to look anything like your process address space, and that is not a problem (for caches, or anything else).
I’m wondering: could one achieve the same level of ergonomicity (lack of lifetimes, Rc, …) by imposing a similar “discipline” with thinking ahead about data storage, and staying within a subset of Rust?
Edit: I guess one would still miss Goose’s memory layout, which is (if I understand correctly) where it wins in performance.
Just the name made me think it would be an esoteric language with instructions encoded as "DUCK DUCK ... GOOSE"
Sources familiar with the matter speculate that the DuckDuckGo browser is going to be rewritten in the language that likely already powers their search backend.
This may be a dumb question, but can't one implement the "N data stacks" in C and thus basically get the principal feature of Goose while staying with C syntax and paying with verbosity?
Goose compiles to C, so yes
Since Goose, compile to C, I guess the answer is yes, but..
With the but part being the really interesting one.
I get a headache reading this Readme. So much llm slop. Is the project itself a vibe as well?
I find it hard to invest any time in learning about a project if the surface symbols indicate it being a low effort project.
It's less being slop and more being technical bomb drop, especially the features section. (And this section pales in comparison to the implementation notes.) Although Claude-generated, it reads fine to programming language nerds like the author but, indeed, will give headaches to those that aren't.
No, it really doesn't read fine. None of this shit reads fine.
>Returns across multiple calls. `return err from load` returns from a function any number of frames up, statically checked, with no unwinder, no `Result` type and no `?` on every call.
Does this mean you have to know the name of the function calling you that's supposed to handle the error? What if you're a library and don't know that?
There was some discussion about this in the Goose discord a few days ago.
One idea that came up was this: you could define a particuda function name as the "landing pad" for handling particular error kinds. Then you "wrap" calls to the library in a function with this name. Here's a part from a larger worked example:
fn catch_io<F: fn()>() -> IoError {
F();
return IoError{ message: "", ok: true }
}
let err = catch_io() { c(); };
https://gist.github.com/bkietz/9bf510299ab62bb4c7f7d2db6eff0...Mind you, this was just discussion, no experience with how well this would work in practice.
Wouldn't it be cooler if you could `return IoError{} from ^` and it would find the closest function in the call stack that can return an IoError?
Even better, you could give it some syntactic sugar like `throw IoError{}`? ;)
P.S. I think the `IoError { message, ok }` type is suspiciously close to `Result<(), String>`.. And if you want to return a value in the success case too it'll become even closer. Perhaps it's best to lean into that and find the calling function that can return an IoError as one of the possible values?
Wow, from the developer of Amiga E: https://strlen.com/amiga-e/
This was my first programming language. Good old times!
Haha small world :)
This is fascinating, and I'm excited to see an entirely different approach in this space. It looks like the learning curve is going to be a little steep, but if it all works, the underlying principle is very elegant.
The very first point under your tutorial is factually incorrect.
var words: u8[][>..] = [];
for i in 5 { words.push(str("word", i)); }
In C++ that is a vector<string>: one heap allocation for the vector,
one per string, a pointer and a capacity per element, and a walk over
all of them when it goes out of scope.
The example you've provided uses strings that are eligible for small string optimization, which avoids per-string allocation. All mainstream STL implementations perform this optimization. You can read about several implementations here: https://devblogs.microsoft.com/oldnewthing/20230803-00/?p=10...That removes the allocation but keeps the overhead of a pointer, a capacity and a fixed buffer.
And these strings in Goose are 6 bytes, while the ones in C++ are apparently 16 to 24 bytes each.
But equally they could be a Rust cold_string::ColdString which is either 8 bytes or 4 bytes depending on your target. The 4 byte ColdString is just the bytes 0x77 0x6f 0x72 0x64 to spell "word" in ASCII / UTF-8 [for 8 bytes the current ColdString just stores 0xFF in the other four bytes to denote they are not used]
Rust has had more interesting SSO types than C++ perhaps explicitly because it doesn't come with SSO out of the box although maybe also because C++ still isn't sure whether text is UTF-8 encoded even though it is 2026 now.
This is the danger of using AI to write your docs and why everyone is asking the author to update them.
I think a human writer could easily have made that error, too.
─ 10 more ─
I don’t think there’s ever been a single statement made about C++ code that didn’t have at least one person come by to explain why it’s incomplete or wrong, and then the same thing happening to that reply itself
─ 6 more ─
That's just Muphry's law (if you write a correction, it will have mistakes in it)
─ 4 more ─
*Murhpy's law
─ 3 more ─
I can't tell if that's a joke I didn't understand, but: https://en.wikipedia.org/wiki/Muphry%27s_law
─ 2 more ─
i love this. I totally was in the Murphy camp lol, everyone says that...? or is it phoneticlaly the same?? o.O Muphry.
─ 1 more ─
Murphy's law is the general case. Muphry’s law is a joke on that specific to writing/spelling. The "*Murhpy's law" comment was a joke of the joke.
There's that guy Bjarne Stroustrup, he wrote a book and I heard there are statements in it.
The problem isn't that a mistake was made, the problem is the nature of the mistake. We can forgive a human author of Goose making a mistake about C++ in the docs.
But what mistakes did the AI make about Goose? If it can say something wrong about a language it has much training data on, what's it saying wrong about a language with no training data at all? How can we trust anything it says about Goose?
Moreover, AI could have caught this mistake so even in using AI, it's clear AI wasn't used proficiently; it should have at least been tasked to proofread stuff like this.
─ 1 more ─
What if it is trained on more correct goose than incorrect c++.
The ol' saying garbage in, garbage out?
i think you are right. you can find many errors and outdatedness in documentation everywhere. Even in Intel/AMD cpu docs etc. once you really get into the meat. same goes for code neatness etc.
Most things which are really close to perfect, have become so over time by feedback and amendments.
I think people who say this type of maybe dont read docs so often.. or only small parts of docs
in C++ this could be done with `cista::raw::vecvec<char>` where only string start positions are stored (end is not necessary because end = start of the next -> 4 byte per string) https://github.com/felixguendling/cista/blob/master/include/...
You can also just copy your strings into the same buffer in C++ if you want to.
The obvious downside is that resizing any string but the last requires moving everything down the stack.
With objects that never need resizing, you can of course have much simpler memory layouts.
If only I had known back when I was buying a floppy of Wolfenstein 3d in the 90s that the game that lets you shoot Nazis and their German shepherds would directly lead to actual Nazi mutant cyborg war dogs.
https://www.motherjones.com/politics/2026/10/palmer-luckey-a...
Can't wait find out what terrible crimes against humanity Goose will cause.
There will never be another new mainstream programming languages.
Maybe I'm dumb but how can a proper language work without heap and only use stack memory, stack only works if you know the size you want before compiling, or am I wrong ?
A stack can grow arbitrarily deep (in practice, assuming 64-bit address space), but it grows only in one dimension. However, you can also have arbitrarily many stacks, so you can have a separate stack for every single thing that can grow in size in your program (by statically analyzing what variables hold data structures that could grow, and how many stacks at most you will need at the peak when program runs).
Rather than salty comments, I just decided to give it a try.
Ported a couple of algorithms from my quite large commercial rust codebase and they were significantly faster in goose. Was wow'd, but the big gain was actually that goose just led the LLM to use more efficient (though admittedly slightly less rust-ideomatic but still safe) data structures, so porting them back kept nearly all of the gain (and in one case, even more).
The obvious 'no shit' comment is 'well your code just wasn't optimized', which is partially true, there was obviously a fair bit left on the table. What I find more interesting is that for darn near zero cost, having an an LLM explore in different languages led to a better outcome than me sitting here running perf and squeezing for cycles.
I'm sure that as I build up a cookbook for my codebase this will be less useful over time, but for now, this is going to be how I approach first order performance optimization.
Nice work, cool tool, plz de-ai the docs :D
Rewrote a little pet project of mine from Rust to Goose. From 17MB ram usage to 6MB ram usage. It's not much but it's honest work.
This looks pretty cool Always wonder about fast low level languages, can you play with its linkage enough to say run it on baremetal x86_64 or so? And how complex is the runtime? is it just transpiled to C? (i can see some notes about spitting out a single C file but wasnt sure)
Either way nice to see more options in this space.
Do you know a bit of an ETA / roadmap for certain features like the dynamically sized moves and struct members?
p.s. love potato and geese so feelin kinda biassed towards being excited about this :D
The runtime is not particularly complex, but making it run with no runtime would still take some doing :)
You'll have to explain what you mean exactly by "dynamically sized moves and struct members".
If any Vim/NeoVim users want to play with the language, I made Vim plugin for Goose:
I know caring about syntax is verboten, but Goose checks off a lot of my dream language syntax features. UFCS, implicit it parameter, trailing block lambdas (with curly braces!), algebraic data types, exhaustive enum matching, pattern matching, etc... the list goes on! It almost looks like Kotlin but more functional b/c it doesn't have the JVM OOP baggage (I'm a big Kotlin fan). And an interesting, fast memory management paradigm to boot! Honestly, even with a garbage collector, this language looks so fun to write and read.
"That looks really neat! The automatic analysis and use of multiple data stacks and resizable fields takes it from "lots of work can be done this way" to "basically everything can be".
The relative references and built in binary structure validation also enable direct memory mapping of data structures and immediate use of network data. "Parsing" file and network data is often 100x slower than it needs to be." - John Carmack