### Run Softbuffer WebAssembly Example

Source: https://github.com/rust-windowing/softbuffer/blob/master/README.md

Command to build and run a Softbuffer example targeting the web backend using `cargo run-wasm`.

```Shell
cargo run-wasm --example winit
```

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

### Run Softbuffer Android Examples

Source: https://github.com/rust-windowing/softbuffer/blob/master/README.md

Commands to build and run Softbuffer examples specifically for Android devices using `cargo apk`, covering both single-threaded and multi-threaded versions.

```Shell
cargo apk r --example winit_android
```

```Shell
cargo apk r --example winit_multithread_android
```

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

### Render Colored Buffer to Winit Window using Softbuffer

Source: https://github.com/rust-windowing/softbuffer/blob/master/README.md

This Rust example initializes a `winit` event loop and window, creates a `softbuffer::Context` and `softbuffer::Surface`, and then continuously draws a unique colored pattern to the window's buffer. It handles window resizing and redraw requests, demonstrating basic graphics rendering with `softbuffer`.

```Rust
use std::num::NonZeroU32;
use std::rc::Rc;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::Window;

#[path = "../examples/utils/winit_app.rs"]
mod winit_app;

fn main() {
    let event_loop = EventLoop::new().unwrap();

    let mut app = winit_app::WinitAppBuilder::with_init(
        |elwt| {
            let window = {
                let window = elwt.create_window(Window::default_attributes());
                Rc::new(window.unwrap())
            };
            let context = softbuffer::Context::new(window.clone()).unwrap();

            (window, context)
        },
        |_elwt, (window, context)| softbuffer::Surface::new(context, window.clone()).unwrap(),
    )
    .with_event_handler(|(window, _context), surface, event, elwt| {
        elwt.set_control_flow(ControlFlow::Wait);

        match event {
            Event::WindowEvent { window_id, event: WindowEvent::RedrawRequested } if window_id == window.id() => {
                let Some(surface) = surface else {
                    eprintln!("RedrawRequested fired before Resumed or after Suspended");
                    return;
                };
                let (width, height) = {
                    let size = window.inner_size();
                    (size.width, size.height)
                };
                surface
                    .resize(
                        NonZeroU32::new(width).unwrap(),
                        NonZeroU32::new(height).unwrap(),
                    )
                    .unwrap();

                let mut buffer = surface.buffer_mut().unwrap();
                for index in 0..(width * height) {
                    let y = index / width;
                    let x = index % width;
                    let red = x % 255;
                    let green = y % 255;
                    let blue = (x * y) % 255;

                    buffer[index as usize] = blue | (green << 8) | (red << 16);
                }

                buffer.present().unwrap();
            }
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                window_id,
            } if window_id == window.id() => {
                elwt.exit();
            }
            _ => {}
        }
    });

    event_loop.run_app(&mut app).unwrap();
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.