Show HN: Wyzer Programming Language

Show HN: Wyzer Programming Language(github.com)

81 points by v0id_isgood 3 hours ago | 37 comments

So i've been working on this project since a few days (or months i should say), it's called wyzer (meaning wiser) it's a statically typed, compiled, resource-oriented programming language with integrated distributed safety via choreographic programming and perceus memory model, The reason why i began this project is out of frustration from Rust, you see it does provide safety for your memory by the strict type checking but what it does not gurantee safety against are distributed deadlocks which is basically a few independent nodes or services wait permanently for resources or messages held by each other, forming a circular wait, the rest are cross-service correctness and protocol mismatch as well. If we are specific over here Wyzer works on mainly generalizing the concept of choreographic programming in a high level programming language because its the very few attempts of actually solving these gaps of safety. Instead of borrow checkers and lifetimes wyzer has linear/affine types and a perceus reference counting which is computationally much simpler for an LSP to understand as well

after 5 months of research and a few weeks of development i am soon going to release version 0.1.0 of it, if you would like to contribute to it you're most welcome!

gokaygurcan 10 minutes ago |

> see a new programing language > look inside > it's rust

asking out of my own ignorance, what's so hard with rust that you cannot convince people and contribute to that directly instead of going on your way? i remember so few of these projects survived over the years. do you think it'll really become something other than your pet project?

jerf 21 minutes ago |

I love the ambition and the fact that this is not just another "state of the art in 2015" language like I see so often. It's trying to do something genuinely different. The field of "taking stuff out of academia and making it work" is a rich and underharvested one.

However, your light is hidden under a basket, to use an old metaphor. I'm having to go digging to find the genuinely new things going on. I suggest recalibrating the entire documentation with a focus on the new stuff. People on HN often complain about not having syntax examples front and center but I would say for you, the very first thing I you should be hitting your new visitors with is the choreography idea.

Set up a simple example of doing something like a concurrent remote counter that is atomically safe by the construction of your language and immediately dive in to what that means. Forget even educating us on the rest of the mundane syntax of the language, immediately dive in to what that is and what that means. I see in the docs/ dir that it probably hurts your programmer mind to cover the choreography before covering sections 1-8, but you can safely assume that if you intrigue with the choreography that they'll hang around to learn about the rest, whereas you can't safely assume that a new reader will wade through all the rest of the relatively mundane details to get to the really interesting stuff.

A modern language with a modern take on compiling a "program" that takes a unified view of the world at the programming language level, and then emits a "server" and a "client" (and perhaps other roles) as separate executables is a pretty nifty idea. Hit it early and hit it hard.

pron 16 minutes ago |

> Go, Java, C#, and Python use garbage collectors. This makes them easier to use but slower and less predictable.

It does not. The term "garbage collectors" covers a whole spectrum of algorithms, some might slow you down (though not for the reason you think) while others were invented to make memory management faster than in C/C++, for other tradeoffs. Python's (mostly) refcounting GC is actually closer to C in its memory management overhead than to either Go or Java. It's very far from what makes Python slow. Go uses a mark-and-sweep collector to find a balanace between speed, FFI, and footprint. Java uses moving collectors, which are faster - and some of which are even more predictable - than memory management in C++. That's because Java is intended to be faster than C++ in large concurrent software, where low-level languages tend to suffer from various overheads due to their requirement for low-level control (Java trades off some performance in smaller programs, but mostly it trades of startup time and footprint).

It is true that slow programming languages tend to use some kind of GC, but that's not what makes them slow, nor does it make the super-fast languages that use a GC (often of a very different kind) any slower; moving collectors (but not refcoting collectors or mark-and-sweep collectors) are an optimisation over free-list approaches, not a compromise for convenience.

hyperhello 2 hours ago |

First of all, the syntax is very generic and conservative. I’m extremely positive about that. It just looks like C or Typescript or Java to me and I don’t see mysterious diacritical marks.

The next thing is, I need more examples. Read me documents can scroll forever and that’s fine. Add examples for every concept your language wants to cover to it. This is your chance to think things through and make the read me and the language astonishing.

And your AI disclaimer (or your AI’s disclaimer) makes sense.

v0id_isgood 2 hours ago | |

i'm actively working on the documentation without AI because it has been an awful experience with it , i've also restricted AI from contributing to it in any way except for helping the developer write their commit messages (Refer to AGENTS.md) properly which is pretty much useless anyways, the language is in it's early stages as well and things might change a lot

v0id_isgood 1 hour ago | |

also , yes i have an example i reprogrammed donut.c in my programming language and called it donut.wyz https://github.com/rudywasfound/donut.wyz go check it out!

snek_case 41 minutes ago | | |

I would like to see an examples directory with a diverse set of example programs. What would be most interesting to me is programs with non-trivial memory usage and data structures, because that's where differences in the memory model would matter. I want to know what's possible and what's not allowed in this language. What makes this different and better than Rust's borrow checker.

vlovich123 1 hour ago |

One thing I don’t understand is how you can guarantee the lack of a distributed deadlock. I’m sure it’s covered in the underlying research, but just conceptually it’s hard to picture.

What stops a choreography where Claire send a message to Bob but Bob is waiting for Alice and Alice is waiting for Claire?

Is it like Rust memory safety where not all valid programs are accepted but all invalid programs are rejected?

I think some examples of the distributed code in action on a trivial and non trivial distributed example is more compelling than a 3d donut render

minraws 57 minutes ago | |

You can think about it as a protocol.

The protocol doesn't describe "Claire sends" and "Bob receives" as two independent actions that wait for each other, it describes them as a single communication in the global program/state.

When it gets executed into code, every send already has a corresponding receive by construction, so you can't write something like "Claire sends to Bob while Bob is actually waiting for Alice" unless the protocol itself allowed that execution.

So the cycle you're describing can't just accidentally appear because of sync issues, because the assumption is a communication is represented correctly at each turn.

So yeah it kinda does limit the set of all possible programs since I would expect not everything can be encoded this way also seems hard to resolve this in practice without only allowing communication b/w Wyzer systems.

I am not very familiar with this topic in practice so OP would be the best person to answer this, I am quite intrigued by how it works in practice as well.

thechao 14 minutes ago |

> Wyzer supports standard if/else, while, and for loops. Note that loops don't need parentheses around the condition.

But why!? You know what'd be cool? If we started supporting control statements that were a bit more sophisticated!

``` do { } while (c) { if (x) break foo; } else { case foo : ...; default : ...; } ```

jitl 2 hours ago |

Your README and docs don’t describe any of the interesting or unique things here. You cover `if` in README but not choreographic programming or perceus. Did i miss some big link?

Where’s the cool stuff?

v0id_isgood 2 hours ago | |

you did read RESEARCH.md didn't you? :)

jitl 1 hour ago | | |

i poked around in there, under choreographic programming there’s one example of something not in the language as a discarded idea.

if you claim X and Y make us cool and different, then you should document X and Y in your readme. don’t tell me something is the star, and then hide it away. this is baffling to me.

andai 1 hour ago | | |

GitHub hides RESEARCH.md for my convenience. I have to click "Show All Files" to see that it even exists.

derdi 1 hour ago | | |

Why would they? The only thing the readme says about RESEARCH.md is "if you want to contribute to the language please read RESEARCH.md". The OP doesn't want to contribute, they want to see an example of choreographic programming. This shouldn't be hard. What is hard is guessing which of the random markdown documents to click to find an example.

hmokiguess 1 hour ago |

I saw this medium post from you https://medium.com/@atixwasfound/how-i-began-writing-my-own-...

In there it says you started this journey when you were 8 years old and that you are a 14 year old programmer

I'm not sure how I feel about this to be honest, I need to process that.

v0id_isgood 1 hour ago | |

time flies :) the grass was greener before though and i miss that!

bckr 57 minutes ago |

I like the ideas a lot. The Readme needs some polish (I think it’s great that it reads as hand-written; an LLM could make suggestions that make it just 10% easier to read).

Is choreographic programming the same as session types?

reactordev 30 minutes ago |

https://github.com/Wyzer-Lang/wyzer#3-control-flow

Is mut a thing? looks like rust.

slifin 27 minutes ago |

Reminds me of https://github.com/lovrosdu/klor

steeleduncan 1 hour ago |

    const MAX: u32 = 100;  // Compile-time constant
    let x: u32 = 10;       // Cannot be changed

If x cannot be changed, how does it differ (meaningfully) from a compile time constant in a safe language, ie in a case of no raw pointers

v0id_isgood 1 hour ago | |

const can be used in places that need a compile-time-known value (like a fixed array size). let can't, even if it obviously holds a fixed number.

netniuq 57 minutes ago |

nice Rust-inspired syntax, although if the main selling point is choreography here, that isn't featured enough on web page or README. Needs more examples/explanation of how that works.

Promising insofar as all of the essentials seem to be right (for me): compiled, good type checker, no garbage checker etc.

andai 1 hour ago |

Very interesting. Maybe this would benefit from concrete examples, of things that are difficult or impossible in other languages, but well supported in Wyzer? I see there's a few high level examples, but I'm thinking concrete scenarios with code snippets might be helpful.

pmarreck 1 hour ago |

> prentensious quote

It's "pretentious."

(said pretentiously, lol)

Hey, at least we know AI didn't write it, lol

pjmlp 1 hour ago |

No mention of the much more mature Chapel, with industry support, given the domain?

manithree 2 hours ago |

docs.wyzer-lang.org doesn't resolve for me, and it's prominently linked from https://wyzer-lang.vercel.app/. Since I'm not familiar with wyzer or perceus, how would one write, say, a doubly linked list in wyzer?

v0id_isgood 1 hour ago | |

docs are under development, you can check them out soon :)

thomasmg 1 hour ago | | |

Great. I'm also writing a new language with the same memory management idea (Perceus-style reference counting / ownership). My language [1] is not functional and currently lacks multi-threading and networking, so there are big differences. But I really like the moto "easy to use memory safety without tracing GC".

[1] https://github.com/thomasmueller/bau-lang/tree/main

jitl 1 hour ago | | |

maybe wait until you have something to share before Show HN? overall your work seems like a cool thing that i’d like to look at in a few months once there’s more substantial education stuff to read about it.

REDA_MAH 1 hour ago |

The syntax is soooo promising but still we need more documentation. Good job anyway for doing such an amazing work with no ai

phplovesong 47 minutes ago |

Ref counting IS a form of GC. It can be slow and have issues in high perf scenarios.

kazinator 1 hour ago |

Compiler should be called Bud.

Made an error? Hold your beer, Bud's got your back: the Bud Wyzer compiler!

vsilent 2 hours ago |

syntax reminds me rust labguage.

v0id_isgood 2 hours ago | |

this is a pretty common observation and yeah it sure is inspired by rust's syntax a bit because i have been a rust dev since quite a long time so i'm much more in favor of it's design philosophy as well