The modern, blazingly fast programming language designed for ultimate developer experience and safety.
// A simple TCP server in Wyzer
fn main() {
let server = std::net::TcpListener::bind("127.0.0.1:8080");
std::io::println("Server running on port 8080...");
for stream in server.incoming() {
std::io::println("New connection!");
stream.write("Hello from Wyzer!");
}
}Imagine you have a bunch of toys (memory and data), and you want to share them with your friends across the room (networks and threads).
Usually, you need three different strict adults (a garbage collector, a borrow checker, and network protocols) to watch everyone and make sure no one fights over the toys or loses them in the air.
Wyzer just teaches everyone one simple rule to share toys perfectly. You write one set of instructions, and Wyzer automatically figures out how to safely pass the toys between you and your friends over the network. No adults needed!
Write code for multiple computers in a single file. The compiler automatically figures out network messages and splits the binaries.
When you call a function on the Sensor from the Server, Wyzer safely transfers the data over the network for you.
role @Server;
role @Sensor;
// This function lives and runs ONLY on the Sensor
fn get_temperature() @ Sensor -> u32 {
return 72u32;
}
fn main() @ Server {
// The Server safely requests data from the Sensor
let data: u32 = transfer(get_temperature(), Server);
std::io::println(data);
}Lightning-fast memory management without a Garbage Collector or a complex Borrow Checker.
If a piece of data has only one owner, the compiler mutates it directly in memory. This makes Wyzer as fast as C, but completely safe by default.
struct Point { x: u32, y: u32 }
fn main() {
var p: Point = Point { x: 10u32, y: 20u32 };
// The compiler knows 'p' is never used again after this.
// Instead of asking for new memory, it overwrites 'p' directly!
var p2: Point = Point { x: 100u32, y: p.y };
}Errors are not hidden. Functions that can fail return a Result<T, E>.
You use match expressions to safely handle both the success (Ok) and error
(Err) cases, guaranteeing you never crash unexpectedly.
fn main() {
let result: Result<u32, str> = Ok(42u32);
match (result) {
Ok(value) => std::io::println(value),
Err(err_msg) => std::io::println(0u32)
};
}Compiled directly to optimized machine code, Wyzer delivers unmatched execution speed without a runtime.
Advanced compile-time checks and the Perceus memory model ensure safety without a garbage collector.
Write less, do more. Clean, explicit syntax inspired by the best modern programming languages.
No async/await split, no hidden exceptions. Everything the compiler does is visible and predictable.
Write code for multiple computers in one file. The compiler splits the binaries and handles the networking.
Role inference allows you to write utility functions that seamlessly execute across any network node without overhead.
No. We want Rust's safety without its steep learning curve. We use a different method (Perceus) for memory, and Rust does not have our network features.
The math works, but it is mostly used in research, not real languages. We want to bring it to a general-purpose language.
Those tools solve specific problems. Wyzer is trying to see if one single rule can solve memory, threads, and networks all at once.
One ownership rule for memory, threads, and networks. No garbage collector, no complex borrow checker, and no network errors.