WASIX

https://wasix.org/docs
Admin
WASIX is a superset of WASI, enabling WebAssembly to run natively on Linux and other operating...
Tokens:90,582
Snippets:256
Trust Score:7.1
Update:1 year ago
Show doc for...
Tokens:
Raw
### Running the gRPC Server

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

This command demonstrates how to start the gRPC server for the helloworld example. It compiles and runs the server binary, which then listens for incoming connections on a specified address.

```bash
$ cargo run --bin helloworld-server
    Finished dev [unoptimized + debuginfo] target(s) in 1.77s
     Running `target/debug/helloworld-server`
Server listening on 127.0.0.1:50051
```

--------------------------------

### Run WASIX Binary with Flags

Source: https://wasix.org/docs/language-guide/c/usage

Example of running a WASIX binary with additional flags, such as enabling threads and network access. This demonstrates how to pass specific runtime options.

```Shell
wasmer run --enable-threads --net   ./target/wasix/debug/hello.wasm
```

--------------------------------

### Basic Axum Application Setup

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This Rust code defines a simple Axum web server. It sets up a single GET route '/' that is handled by the 'handler' function, which returns a static string. The server listens on `http://127.0.0.1:3000`.

```rust
use axum::{routing::get, Router};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    // Building our application with a single Route
    let app = Router::new().route("/", get(handler));

    // Run the server with hyper on http://127.0.0.1:3000
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn handler() -> &'static str {
    "Hello, Axum ❤️ WASIX!"
}
```

--------------------------------

### Install WASIX for Rust

Source: https://wasix.org/docs/language-guide/rust/installation

Installs the WASIX toolchain and related components for Rust development using the cargo-wasix command-line tool. This requires the rustup toolchain manager to be installed.

```bash
$ cargo install cargo-wasix
```

--------------------------------

### WASIX Spawn Example

Source: https://wasix.org/docs/language-guide/c/examples

Illustrates the Spawn system call in WASIX for creating new processes. This is an alternative to Fork/Exec for process creation.

```c
/* Spawn example code */
// Requires WASIX environment
// Note: WASIX spawn might have specific implementations
#include <stdio.h>

int main() {
    // Placeholder for spawn usage
    // The actual WASIX spawn API might differ from POSIX spawn
    printf("WASIX Spawn example placeholder.\n");
    return 0;
}
```

--------------------------------

### WASIX Execve Example

Source: https://wasix.org/docs/language-guide/c/examples

Provides an example of the Execve system call in WASIX, used for executing a new program. This is fundamental for process management.

```c
/* Execve example code */
// Requires WASIX environment
#include <unistd.h>

int main() {
    char *args[] = {"/bin/program", NULL};
    char *env[] = {NULL};
    execve("/bin/program", args, env);
    // execve only returns on error
    return 1;
}
```

--------------------------------

### Create WASIX Readdir Project Directory

Source: https://wasix.org/docs/language-guide/c/tutorials/readdir

This snippet shows the shell commands to create a new directory for the WASIX readdir project and navigate into it.

```Shell
mkdir wasix-readdir
cd wasix-readdir
```

--------------------------------

### WASIX Signal Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates handling signals using the Signal system call in WASIX. This example shows how to register a signal handler.

```c
/* Signal example code */
// Requires WASIX environment
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

void sigint_handler(int signum) {
    printf("\nReceived SIGINT (%d)\n", signum);
}

int main() {
    signal(SIGINT, sigint_handler);
    printf("Waiting for SIGINT...\n");
    pause(); // Wait for a signal
    return 0;
}
```

--------------------------------

### Verify WASIX Toolchain Installation

Source: https://wasix.org/docs/language-guide/rust/installation

Checks if the WASIX toolchain has been correctly installed and is available in the rustup toolchain list.

```bash
$ rustup toolchain list | grep wasix
wasix
```

--------------------------------

### WASIX Fork Longjmp Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates the interaction between the Fork and Longjmp system calls in WASIX. This example shows process creation and non-local goto.

```c
/* Fork Longjmp example code */
// Requires WASIX environment
#include <unistd.h>
#include <setjmp.h>

jmp_buf env;

void child_process() {
    // ... perform some operations ...
    longjmp(env, 1);
}

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        child_process();
    } else {
        if (setjmp(env) == 0) {
            // Parent process waits or continues
        }
    }
    return 0;
}
```

--------------------------------

### WASIX Readdir Tree Example

Source: https://wasix.org/docs/language-guide/c/examples

Provides an example of traversing a directory tree using WASIX system calls like opendir, readdir, and closedir. This is useful for file system operations.

```c
/* Readdir Tree example code */
// Requires WASIX environment
#include <stdio.h>
#include <dirent.h>

void traverse_dir(const char *path) {
    DIR *dir = opendir(path);
    struct dirent *entry;

    if (dir == NULL) {
        perror("opendir");
        return;
    }

    while ((entry = readdir(dir)) != NULL) {
        printf("%s\n", entry->d_name);
        // Potentially recurse for subdirectories
    }

    closedir(dir);
}

int main() {
    traverse_dir("."); // Traverse current directory
    return 0;
}
```

--------------------------------

### WASIX Vfork Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates the Vfork system call in WASIX, which creates a new process that shares memory with the parent until a call to execve or exit. Use with caution.

```c
/* Vfork example code */
// Requires WASIX environment
#include <unistd.h>
#include <stdio.h>

int main() {
    int x = 10;
    pid_t pid = vfork();

    if (pid == 0) { // Child process
        // Child shares memory with parent
        x = 20;
        printf("Child: x = %d\n", x);
        _exit(0); // Must use _exit in vfork child
    } else if (pid > 0) {
        // Parent process
        printf("Parent: x = %d\n", x); // x might be 20 if child hasn't exited yet
    } else {
        // Error handling
        perror("vfork failed");
        return 1;
    }
    return 0;
}
```

--------------------------------

### WASIX File Copy Example

Source: https://wasix.org/docs/language-guide/c/examples

Illustrates how to perform file copying operations using WASIX system calls. This example covers reading from one file and writing to another.

```c
/* File Copy example code */
// Requires WASIX environment
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd_src = open("source.txt", O_RDONLY);
    int fd_dst = open("destination.txt", O_WRONLY | O_CREAT, 0644);
    char buffer[1024];
    ssize_t bytes_read;

    while ((bytes_read = read(fd_src, buffer, sizeof(buffer))) > 0) {
        write(fd_dst, buffer, bytes_read);
    }

    close(fd_src);
    close(fd_dst);
    return 0;
}
```

--------------------------------

### Verify cargo-wasix Installation

Source: https://wasix.org/docs/language-guide/rust/installation

Verifies that the cargo-wasix command-line tool has been installed correctly by checking its version.

```bash
$ cargo wasix --version
cargo-wasix 0.1.17
```

--------------------------------

### Compile C Application with WASIX

Source: https://wasix.org/docs/language-guide/c/tutorials/readdir

This snippet shows the command to compile a C program using the WASIX SDK, targeting WebAssembly 32-bit WASI.

```Shell
/path/to/wasix-sdk/clang readdir.c --target="wasm32-wasi" -o readdir.wasm
```

--------------------------------

### Rust Project Setup for WASIX gRPC

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Demonstrates the initial steps for setting up a Rust project for WASIX gRPC communication. This includes creating a new binary project, deleting the default main file, creating server and client entry points, and setting up a proto directory.

```bash
$ cargo new --bin wasix-grpc
    Created binary (application) `wasix-grpc` package

$ rm src/main.rs

$ touch src/server.rs src/client.rs

$ mkdir proto
$ touch proto/helloworld.proto
```

--------------------------------

### Run WASIX Application

Source: https://wasix.org/docs/language-guide/c/tutorials/readdir

This snippet demonstrates how to run the compiled WASIX WebAssembly module using the wasmer runtime, providing the root directory as an argument.

```Shell
wasmer run readdir.wasm /
```

--------------------------------

### Testing gRPC Server and Client

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Provides shell commands to run the compiled Rust gRPC server and client. It shows the expected output for both starting the server and receiving a response from the client.

```Shell
$ cargo run --bin helloworld-server
    Finished dev [unoptimized + debuginfo] target(s) in 0.14s
     Running `target/debug/helloworld-server`
Server listening on 127.0.0.1:50051
```

```Shell
$ cargo run --bin helloworld-client
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/helloworld-client`
RESPONSE=Response { metadata: MetadataMap { headers: {"content-type": "application/grpc", "date": "Mon, 28 Aug 2023 12:54:16 GMT", "grpc-status": "0"} }, message: HelloReply { message: "Hello Tonic!" }, extensions: Extensions }
```

--------------------------------

### WASIX Epoll Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates the usage of the Epoll system call within the WASIX environment. This example showcases asynchronous event notification.

```c
/* Epoll example code */
// Requires WASIX environment
#include <sys/epoll.h>

int main() {
    int epfd = epoll_create1(0);
    // ... epoll setup and usage ...
    return 0;
}
```

--------------------------------

### Benchmark WASIX Binary with cargo wasix

Source: https://wasix.org/docs/language-guide/rust/usage

This command enables benchmarking of WASIX binaries through `cargo wasix`. The Wasmer runtime needs to be installed.

```bash
$ cargo wasix bench <path-to-wasm-file>
```

--------------------------------

### Create readdir.c file

Source: https://wasix.org/docs/language-guide/c/tutorials/readdir

This snippet shows the shell command to create an empty C source file named readdir.c.

```Shell
touch readdir.c
```

--------------------------------

### WASIX Pipe Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates the creation and usage of pipes for inter-process communication (IPC) in WASIX. This example shows data transfer between processes.

```c
/* Pipe example code */
// Requires WASIX environment
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    int pipefd[2];
    char buffer[32];

    pipe(pipefd);

    pid_t pid = fork();

    if (pid == 0) { // Child process
        close(pipefd[0]); // Close read end
        write(pipefd[1], "Hello from child!\n", strlen("Hello from child!\n"));
        close(pipefd[1]); // Close write end
    } else { // Parent process
        close(pipefd[1]); // Close write end
        read(pipefd[0], buffer, sizeof(buffer) - 1);
        buffer[sizeof(buffer) - 1] = '\0';
        printf("Parent received: %s", buffer);
        close(pipefd[0]); // Close read end
    }
    return 0;
}
```

--------------------------------

### Compile C to WASIX

Source: https://wasix.org/docs/language-guide/c/usage

Instructions for compiling a C program to WASIX format. This requires setting up environment variables for the compiler, sysroot, and linker.

```Shell
export CC=wasi-sdk/clang
export SYSROOT=wasix-libc/sysroot
export LLD_PATH=wasi-sdk/lld
```

--------------------------------

### WASIX Fork Example

Source: https://wasix.org/docs/language-guide/c/examples

An example showcasing the Fork system call in WASIX for creating new processes. This is a fundamental operation for multitasking.

```c
/* Fork example code */
// Requires WASIX environment
#include <unistd.h>
#include <stdio.h>

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // Error handling
        return 1;
    } else if (pid == 0) {
        // Child process
        printf("This is the child process.\n");
    } else {
        // Parent process
        printf("This is the parent process, child PID: %d\n", pid);
    }
    return 0;
}
```

--------------------------------

### Test WASIX Binary with cargo wasix

Source: https://wasix.org/docs/language-guide/rust/usage

This command allows you to run tests for a compiled WASIX binary using `cargo wasix`. The Wasmer runtime must be installed prior to execution.

```bash
$ cargo wasix test <path-to-wasm-file>
```

--------------------------------

### Setup Hyper Server in Rust for WASIX

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-reqwest

Sets up a basic Hyper server in the main.rs file to listen for incoming requests on port 3000. It configures the server to use a `handle` function for processing connections, which is the entry point for forwarding requests.

```rust
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));\n\n    println!("Listening on {}", addr);\n\n    // And a MakeService to handle each connection...\n    let make_service = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) });\n    //                                                                            ^^^^^^ \n    // \ud83d\udc41\ufe0f Focus here - This handle function is what connects to the part 2 of our application.\n \n    // Then bind and serve...\n    let server = Server::bind(&addr).serve(make_service);\n\n    // And run forever...\n    Ok(server.await?)
```

--------------------------------

### WASIX Getrandom Example

Source: https://wasix.org/docs/language-guide/c/examples

Demonstrates the Getrandom system call in WASIX for obtaining cryptographically secure pseudo-random numbers. This is crucial for security-sensitive applications.

```c
/* Getrandom example code */
// Requires WASIX environment
#include <sys/random.h>
#include <stdio.h>

int main() {
    unsigned char buf[16];
    ssize_t bytes_read = getrandom(buf, sizeof(buf), 0);

    if (bytes_read == sizeof(buf)) {
        printf("Generated random bytes:\n");
        for (int i = 0; i < sizeof(buf); ++i) {
            printf("%02x", buf[i]);
        }
        printf("\n");
    } else {
        perror("getrandom failed");
        return 1;
    }
    return 0;
}
```

--------------------------------

### Run WASIX Binary

Source: https://wasix.org/docs/language-guide/c/usage

Command to execute a WASIX binary using the wasmer-cli. This involves specifying the path to the compiled WebAssembly file.

```Shell
$ wasmer run <path-to-wasm-file>
```

--------------------------------

### Run WASIX Binary with wasmer CLI and Flags

Source: https://wasix.org/docs/language-guide/rust/usage

Demonstrates running a WASIX binary using the `wasmer` CLI with additional runtime flags like `--enable-threads` and `--net`. The Wasmer runtime is required.

```bash
wasmer run --enable-threads --net   ./target/wasix/debug/hello.wasm
```

--------------------------------

### WASIX Longjmp Example

Source: https://wasix.org/docs/language-guide/c/examples

Illustrates the use of the Longjmp system call in WASIX for performing a non-local goto. This is often used in conjunction with setjmp for error handling.

```c
/* Longjmp example code */
// Requires WASIX environment
#include <setjmp.h>
#include <stdio.h>

jmp_buf buf;

void function_that_jumps() {
    printf("About to jump\n");
    longjmp(buf, 1);
}

int main() {
    if (setjmp(buf) == 0) {
        function_that_jumps();
    } else {
        printf("Returned from jump\n");
    }
    return 0;
}
```

--------------------------------

### Contributing to cargo-wasix

Source: https://wasix.org/docs/developer-guide/rust

Contributions to `cargo-wasix` are welcome, particularly for adding new command-line arguments or enabling persistent configuration for default runtime changes. Accepted pull requests will lead to a republished package on crates.io.

```bash
# Example of submitting a pull request for new features
# git checkout -b feature-branch
# git add .
git commit -m "Add feature: change default runtime"
git push origin feature-branch
```

--------------------------------

### WASIX: Socket Creation and Configuration

Source: https://wasix.org/docs/explanation/extensions-to-wasi

Enables opening sockets, setting and getting various socket options including flags and timeouts, and setting socket buffer sizes.

```WASI
sock_open
```

```WASI
sock_set_opt_flag
```

```WASI
sock_get_opt_flag
```

```WASI
sock_set_opt_time
```

```WASI
sock_get_opt_time
```

```WASI
sock_set_opt_size
```

```WASI
sock_get_opt_size
```

--------------------------------

### Testing WASIX Server with Curl

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This example demonstrates how to send an HTTP request to a WASIX-based web server using `curl`. It targets `http://localhost:3000`, the default address for the axum server example, to verify its functionality.

```bash
$ curl http://localhost:3000
```

--------------------------------

### Test Axum Application with Curl

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This command uses 'curl' to send an HTTP GET request to the running Axum server at `http://127.0.0.1:3000` and displays the response.

```bash
curl http://127.0.0.1:3000
Hello, Axum ❤️ WASIX!%
```

--------------------------------

### Rust Threading Example

Source: https://wasix.org/docs/language-guide/rust/tutorials/threading

This Rust code demonstrates basic threading. It spawns a new thread that prints numbers and sleeps, while the main thread also prints numbers and sleeps. The main thread then waits for the spawned thread to complete using `join()`.

```Rust
use std::thread;
use std::time::Duration;
 
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
 
    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
 
    handle.join().unwrap();
}
```

--------------------------------

### Rust Server Setup with TLS

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

This Rust code configures a gRPC server using Tonic and Tokio-Rustls to support HTTPS. It loads server certificates and keys, sets up TLS with ALPN, and handles incoming connections, upgrading them to TLS before serving requests. It also includes a basic Greeter service implementation.

```rust
use hyper::server::conn::Http;
use tokio_rustls::rustls::{OwnedTrustAnchor, RootCertStore, ServerConfig};
use tonic::{transport::Server, Request, Response, Status};
 
use hello_world::greeter_server::Greeter;
use hello_world::{HelloReply, HelloRequest};
 
use tokio::sync::mpsc;
use tokio_stream::{wrappers::ReceiverStream, Stream, StreamExt};
 
use std::error::Error;
use std::io::ErrorKind;
use std::pin::Pin;
use std::time::Duration;
 
use std::sync::Arc;
use tokio::net::TcpListener;
use tokio_rustls::{
    rustls::{Certificate, PrivateKey},
    TlsAcceptor,
};
use tower_http::ServiceBuilderExt;
 
pub mod hello_world {
    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
}
 
#[derive(Debug, Default)]
pub struct MyGreeter {}
 
#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn send(&self, request: Request<HelloRequest>) -> Result<Response<HelloReply>, Status> {
        Ok(Response::new(HelloReply {
            message: format!("hello {}", request.get_ref().name),
        }))
    }
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let data_dir = if cfg!(target_os = "wasi") {
        std::env::current_dir()?.
    } else {
        std::path::PathBuf::from(std::env!("CARGO_MANIFEST_DIR"))
    };
    let certs = {
        let fd = std::fs::File::open(data_dir.join("tls/server.pem"))?;
        let mut buf = std::io::BufReader::new(&fd);
        rustls_pemfile::certs(&mut buf)?
            .into_iter()
            .map(Certificate)
            .collect()
    };
    let key = {
        let fd = std::fs::File::open(data_dir.join("tls/server.key"))?;
        let mut buf = std::io::BufReader::new(&fd);
        rustls_pemfile::pkcs8_private_keys(&mut buf)?
            .into_iter()
            .map(PrivateKey)
            .next()
            .unwrap()
    };
 
    let mut tls = ServerConfig::builder()
        .with_safe_defaults()
        .with_no_client_auth()
        .with_single_cert(certs, key)?;
    tls.alpn_protocols = vec![b"h2".to_vec()];
 
    let server = MyGreeter::default();
 
    let svc = Server::builder()
        .add_service(hello_world::greeter_server::GreeterServer::new(server))
        .into_service();
 
    let mut http = Http::new();
    http.http2_only(true);
 
    let listener = TcpListener::bind("127.0.0.1:50051").await?;
    let tls_acceptor = TlsAcceptor::from(Arc::new(tls));
 
    println!("Server listening on {}", listener.local_addr()?);
 
    loop {
        let (conn, addr) = match listener.accept().await {
            Ok(incoming) => incoming,
            Err(e) => {
                eprintln!("Error accepting connection: {}", e);
                continue;
            }
        };
 
        let http = http.clone();
        let tls_acceptor = tls_acceptor.clone();
        let svc = svc.clone();
 
        tokio::spawn(async move {
            let mut certificates = Vec::new();
 
            let conn = tls_acceptor
                .accept_with(conn, |info| {
                    if let Some(certs) = info.peer_certificates() {
                        for cert in certs {
                            certificates.push(cert.clone());
                        }
                    }
                })
                .await
                .unwrap();
 
            let svc = tower::ServiceBuilder::new()
                .add_extension(Arc::new(ConnInfo { addr, certificates }))
                .service(svc);
 
 
            http.serve_connection(conn, svc)
                .await
                .map_err(|e| {
                    eprintln!("Error serving connection: {}", e);
                    e
                })
                .unwrap();
        });
    }
}

#[derive(Debug)]
struct ConnInfo {
    addr: std::net::SocketAddr,
    certificates: Vec<Certificate>,
}

```

--------------------------------

### Clone WASIX Repositories for Rust Development

Source: https://wasix.org/docs/developer-guide/rust

To develop WASIX syscalls in Rust, you need to clone specific repositories. These include the libc repository, the wasix-witx repository, and a fork of wasix-abi-rust.

```bash
git clone <url_to_libc_repo>
git clone <url_to_wasix_witx_repo>
git clone <url_to_wasix_abi_rust_fork>
```

--------------------------------

### Build WASIX Binary with cargo wasix

Source: https://wasix.org/docs/language-guide/rust/usage

Use this command to build a Rust project for the WASIX target using `cargo wasix`. The Wasmer runtime is a prerequisite.

```bash
$ cargo wasix build
```

--------------------------------

### WASIX Readdir C Application

Source: https://wasix.org/docs/language-guide/c/tutorials/readdir

This C code demonstrates how to read directory contents recursively using opendir and readdir functions. It takes a directory path as a command-line argument and prints each entry. It includes error handling for incorrect argument counts and checks for directory entries to avoid infinite recursion.

```C
#include <stdio.h>
#include <string.h>
#include <sys/random.h>
#include <unistd.h>
#include <dirent.h> // header file for functions for accessing directories

/**
 * Recursive function to print the directory entries
 */
int print_dir(char *name)
{

    /**
     * Return here or else the program will go into infinite recursion
     */
    if (strcmp(name, "..") == 0 || strcmp(name, ".") == 0 || name == NULL)
    {
        return 1;
    }
    DIR *d = opendir(name); // open the directory and return a pointer to the directory stream
    for (;;)
    {
        struct dirent *ent = readdir(d); // read the next directory entry from the directory stream
        if (ent == NULL)
        {
            break;
        }
        if (strcmp(ent->d_name, "..") == 0 || strcmp(ent->d_name, ".") == 0)
        {
            continue;
        }
        printf("dir entry name - '%s'\n", ent->d_name);

        /**
         * If the entry is a directory then recursively call the function
         */
        print_dir(ent->d_name);
    }
    return 0;
}

int main(int argc, char **argv)
{
    /**
     * If the length of arguments is not equal to 2 then print the usage and return
     */
    if (argc != 2)
    {
        fprintf(stderr, "usage: %s <dir>\n", argv[0]);
        return 1;
    }

    char *name = argv[1]; // name of the directory
    printf("main: just before opening dir '%s'\n", name);
    fflush(stdout);
    // call the recursive function
    print_dir(name);
    return 0;
}
```

--------------------------------

### Using cargo-wasix for WASIX Applications

Source: https://wasix.org/docs/developer-guide/rust

`cargo-wasix` is a command-line tool that extends the functionality of `cargo` for WASIX applications. It enables building, running, and benchmarking WASIX projects. Development of `cargo-wasix` itself requires forking the `cargo-wasix` crate.

```bash
cargo-wasix build
cargo-wasix run
cargo-wasix bench
```

--------------------------------

### Run WASIX Binary with cargo wasix

Source: https://wasix.org/docs/language-guide/rust/usage

This command is used to execute a compiled WASIX binary file using the `cargo wasix` tool. Ensure the Wasmer runtime is installed.

```bash
$ cargo wasix run <path-to-wasm-file>
```

--------------------------------

### Create New Rust Project

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This command initializes a new Rust binary project named 'wasix-axum' using Cargo, the Rust package manager.

```bash
cargo new --bin wasix-axum
     Created binary (application) `wasix-axum` package
```

--------------------------------

### Create New Rust Project for WASIX

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-reqwest

Initializes a new Rust binary project named 'wasix-reqwest-proxy' using Cargo. This sets up the basic file structure for the WASIX application.

```bash
$ cargo new --bin wasix-reqwest-proxy\n     Created binary (application) `wasix-reqwest-proxy` package
```

--------------------------------

### Create New Rust Project

Source: https://wasix.org/docs/language-guide/rust/tutorials/threading

This snippet shows the command to create a new binary Rust project using Cargo. It initializes the project structure, including source files and configuration.

```Shell
cargo new --bin wasix-threading
     Created binary (application) `wasix-threading` package
```

--------------------------------

### Running the gRPC Client

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

This command shows how to compile and execute the gRPC client. Upon successful execution, it sends a request to the server and prints the received response, confirming the client-server communication.

```bash
$ cargo run --bin helloworld-client
    Finished dev [unoptimized + debuginfo] target(s) in 2.55s
     Running `target/debug/helloworld-client`
RESPONSE=Response { metadata: MetadataMap { headers: {"content-type": "application/grpc", "date": "Mon, 28 Aug 2023 13:29:27 GMT", "grpc-status": "0"} }, message: HelloReply { message: "hello Alice" }, extensions: Extensions }
```

--------------------------------

### Run with WASIX

Source: https://wasix.org/docs/language-guide/rust/tutorials/threading

This command executes a Rust application compiled for WASIX. It shows the compilation and execution steps, including running the WebAssembly binary, and the output is similar to the native execution.

```Shell
cargo wasix run
    Finished dev [unoptimized + debuginfo] target(s) in 0.09s
     Running `cargo-wasix target/wasm32-wasmer-wasi/debug/wasix-threading.wasm`
info: Post-processing WebAssembly files
     Running `target/wasm32-wasmer-wasi/debug/wasix-threading.wasm`
hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!

```

--------------------------------

### Create and Run Condvar Example in Rust

Source: https://wasix.org/docs/language-guide/rust/tutorials/condvar

This Rust code demonstrates the use of a condition variable (Condvar) and a mutex to synchronize threads. It spawns a secondary thread that sleeps for a second, signals the condvar, and the main thread waits for this signal before proceeding. This example requires Rust and the WASIX runtime.

```bash
$ cargo new --bin wasix-condvar
     Created binary (application) `wasix-condvar` package
```

```toml
[package]
name = "wasix-condvar"
version = "0.1.0"
edition = "2021"

[dependencies]

```

```rust
use std::{
    sync::{Arc, Condvar, Mutex},
    thread,
    time::Duration,
};

/// Inside of our lock, spawn a new thread, and then wait for it to start.
fn main() {
    // create a condvar, which is a shared object that threads can use to wait for another thread to wake them up.
    let pair = Arc::new((Mutex::new(false), Condvar::new()));

    // We enter a lock
    let (lock, cvar) = &*pair;

    // acquire the lock on the boolean
    let mut started = lock.lock().unwrap();

    println!("condvar-secondary thread spawn");
    {
        let pair = Arc::clone(&pair);
        thread::spawn(move || {
            {
                println!("condvar-secondary thread started");
                let (lock, cvar) = &*pair;

                //sleep the secondary thread for 1 second so that the main thread can wait for it
                println!("condvar-secondary thread sleep(1sec) start");
                thread::sleep(Duration::from_secs(1));
                println!("condvar-secondary thread sleep(1sec) end");

                // acquire the lock on the boolean and
                let mut started = lock.lock().unwrap();
                *started = true;
                println!("condvar-secondary thread set condition");
                // We notify the condvar that the value has changed.
                cvar.notify_one();
                println!("condvar-secondary thread notify");
            }
            thread::sleep(Duration::from_millis(50));
            println!("condvar-secondary thread exit");
        });
    }
    thread::sleep(Duration::from_millis(100));

    // Wait for the thread to start up.
    println!("condvar-main loop");

    // check the boolean value and if it is false, wait for the condvar to be notified
    while !*started {
        println!("condvar-main wait");
        // We wait for the condvar to be notified.
        started = cvar.wait(started).unwrap();
        println!("condvar-main woken");
    }
    println!("condvar-main parent done");

    // sleep for 1 second so that the secondary thread can exit
    thread::sleep(Duration::from_millis(100));

    println!("all done");
}

```

```bash
$ cargo run
   Compiling wasix-condvar v0.1.0 (/wasix-condvar)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/wasix-condvar`
condvar-secondary thread spawn
condvar-secondary thread started
condvar-secondary thread sleep(1sec) start
condvar-main loop
condvar-main wait
condvar-secondary thread sleep(1sec) end
condvar-secondary thread set condition
condvar-secondary thread notify
condvar-main woken
condvar-main parent done
condvar-secondary thread exit
all done
```

--------------------------------

### Prepare Input and Output Files

Source: https://wasix.org/docs/language-guide/c/tutorials/file-copy

Shell commands to create an input text file with content and an empty output file for testing the file copy program.

```Shell
$ touch input.txt
$ echo "Hello, World!" > input.txt
$ touch output.txt
```

--------------------------------

### Create WASIX Signal Project Directory

Source: https://wasix.org/docs/language-guide/c/tutorials/signal

This snippet shows the shell commands to create a new directory for the WASIX signal project and navigate into it.

```Shell
mkdir wasix-signal
cd wasix-signal
```

--------------------------------

### WASIX: TTY Property Management

Source: https://wasix.org/docs/explanation/extensions-to-wasi

Enables getting and setting TTY properties, allowing control over terminal behavior.

```WASI
tty_get
```

```WASI
tty_set
```

--------------------------------

### Create a new Rust project for WASIX

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-spawn

This command initializes a new binary Rust project named 'wasix-spawn'. It sets up the basic directory structure and necessary files for a Rust application.

```Shell
cargo new --bin wasix-spawn
     Created binary (application) `wasix-spawn` package
```

--------------------------------

### Protobuf Definition for gRPC Service

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Defines a simple gRPC service named 'Greeter' with a 'Send' RPC method that takes a 'HelloRequest' and returns a 'HelloReply'. This file specifies the message structures for requests and responses.

```protobuf
// proto/helloworld.proto

syntax = "proto3";
package helloworld;

service Greeter {
    rpc Send(HelloRequest) returns (HelloReply) {}

}

message HelloRequest {
   string name = 1;
}

message HelloReply {
    string message = 1;
}
```

--------------------------------

### Create Project Directory and File

Source: https://wasix.org/docs/language-guide/c/tutorials/file-copy

Commands to create a new directory for the WASIX file copy project and an empty C source file.

```Shell
$ mkdir wasix-file-copy
$ cd wasix-file-copy
$ touch file-copy.c
```

--------------------------------

### WASIX: Socket Status and Address Information

Source: https://wasix.org/docs/explanation/extensions-to-wasi

Provides functions to get the status of a socket and retrieve local and peer address information.

```WASI
sock_status
```

```WASI
sock_addr_local
```

```WASI
sock_addr_peer
```

--------------------------------

### Rust gRPC Server Implementation

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Implements a gRPC server using Tonic in Rust. It defines a Greeter service with a 'send' method that echoes a 'Hello' message back to the client. The server listens on a specified address.

```Rust
// src/server.rs
use tonic::{transport::Server, Request, Response, Status};
 
use hello_world::greeter_server::{Greeter, GreeterServer};
use hello_world::{HelloReply, HelloRequest};
 
pub mod hello_world {
    tonic::include_proto!("helloworld"); // The string specified here must match the proto package name
}
 
#[derive(Debug, Default)]
pub struct MyGreeter {}
 
#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn send(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloReply>, Status> {
        println!("Got a request: {:?}", request);
 
        let reply = HelloReply {
            message: format!("Hello {}!", request.into_inner().name),
        };
 
        Ok(Response::new(reply))
    }
}
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "127.0.0.1:50051".parse()?;
    let greeter = MyGreeter::default();
 
    println!("Server listening on {}", addr);
 
    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;
 
    Ok(())
}
```

--------------------------------

### Create WASIX Spawn Project Directory

Source: https://wasix.org/docs/language-guide/c/tutorials/spawn

Commands to create a new directory for a WASIX spawning project and navigate into it.

```shell
mkdir wasix-spawn
cd wasix-spawn
```

--------------------------------

### Rust build.rs for Proto Compilation

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

A build script (`build.rs`) that uses `tonic-build` to compile Protocol Buffers (`.proto`) files into Rust code. This is essential for generating the gRPC service and message structures.

```rust
// build.rs
fn main() -> Result<(), Box<dyn std::error::Error>> {
    tonic_build::compile_protos("proto/helloworld.proto")?;
    Ok(())
}
```

--------------------------------

### WASIX thread_spawn() Syntax

Source: https://wasix.org/docs/api-reference/wasix/thread_spawn

Defines the syntax for the `thread_spawn_v2` function in WASIX, which creates a new thread. It takes a pointer to thread start arguments and returns a thread ID or an error.

```witx
;;; Creates a new thread by spawning that shares the same
;;; memory address space, file handles and main event loops.
;;; The web assembly process must export function named 'wasi_thread_start'
(@interface func (export "thread_spawn_v2")
  ;;; Pointer to the structure the describes the thread
  ;;; that is being spawened
  (param $args (@witx pointer $thread_start))
  ;;; Returns the thread index of the newly created thread
  ;;; (indices always start from zero)
  (result $error (expected $tid (error $errno)))
)
```

--------------------------------

### Run Axum Application

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This command compiles and runs the Rust application using Cargo. It shows the compilation process and indicates that the server is running.

```bash
cargo run
   Compiling wasix-axum v0.1.0 (/wasix-axum)
    Finished dev [unoptimized + debuginfo] target(s) in 1.41s
     Running `target/debug/wasix-axum`
```

--------------------------------

### Run WASIX gRPC Server with Wasmer

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Executes a WASIX gRPC server compiled to WebAssembly using the Wasmer runtime. It enables networking support and maps a host directory to a WASIX filesystem path.

```bash
$ wasmer run target/wasm32-wasmer-wasi/release/helloworld-server.wasm --net --mapdir /tls:./tls
Server listening on 127.0.0.1:50051
```

--------------------------------

### Run WASI with Wasmer

Source: https://wasix.org/docs/language-guide/rust/tutorials/condvar

Executes a WASI-compiled WebAssembly binary using the Wasmer runtime. This example shows the output when running the WASI binary, including a panic due to unsupported threading operations.

```bash
$wasmer target/wasm32-wasi/debug/wasix-condvar.wasm --enable-all
condvar-secondary thread spawn
thread 'main' panicked at 'failed to spawn thread: Error { kind: Unsupported, message: "operation not supported on this platform" }', /rustc/7908a1d65496b88626e4b7c193c81d777005d6f3/library/std/src/thread/mod.rs:683:29
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: failed to run `target/wasm32-wasi/debug/wasix-condvar.wasm`
╰─▶ 1: RuntimeError: unreachable
```

--------------------------------

### Compile Rust Project to WASIX

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-grpc

Builds a Rust project for the WASIX target using Cargo. This command compiles the code and outputs WebAssembly files, potentially with warnings during the build process.

```bash
$ cargo wasix build --release
...
warning: `wasix-grpc` (bin "helloworld-server") generated 2 warnings (run `cargo fix --bin "helloworld-server"` to apply 1 suggestion)
warning: `wasix-grpc` (bin "helloworld-client") generated 6 warnings (run `cargo fix --bin "helloworld-client"` to apply 3 suggestions)
    Finished release [optimized] target(s) in 26.41s
info: Post-processing WebAssembly files
  Optimizing with wasm-opt
  Optimizing with wasm-opt
```

--------------------------------

### Building a WASIX Project with Cargo

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This command demonstrates how to build a Rust project configured for WASIX. It utilizes the `cargo wasix build` command, which handles the necessary compilation steps for WebAssembly targets.

```bash
$ cargo wasix build
```

--------------------------------

### C Compiler Support for WASIX

Source: https://wasix.org/docs/index

WASIX offers support for the C programming language, including an installable toolchain. This allows C/C++ developers to compile and run their applications on WebAssembly using WASIX, leveraging its POSIX compatibility.

```C
// C compiler support (including an installable toolchain)
// Example usage would involve compiling C code with a WASIX-enabled toolchain.
```

--------------------------------

### Cargo.toml Dependencies

Source: https://wasix.org/docs/language-guide/rust/tutorials/wasix-axum

This snippet shows the updated 'Cargo.toml' file after adding the 'axum' and 'tokio' dependencies with specific versions and features.

```toml
[package]
name = "wasix-axum"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = { version = "0.6.18", features = ["tokio"] }
tokio = { version = "1.28.1", features = ["full"] }
```

--------------------------------

### Create spawn.c File

Source: https://wasix.org/docs/language-guide/c/tutorials/spawn

Command to create an empty C source file named spawn.c.

```shell
touch spawn.c
```
Tokens:
Raw