### Run Glutin Example Window (Bash)

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

This command demonstrates how to clone the Glutin repository, navigate into the directory, and run the 'window' example using Cargo. It's a quick way to test the library's basic functionality.

```bash
git clone https://github.com/rust-windowing/glutin
cd glutin
cargo run --example window
```

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

### Compile and Run Android Example (Console)

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

This command shows how to compile and run the Android example for Glutin using `cargo-apk`. It requires `cargo-apk` to be installed and is used to test Glutin's functionality on Android devices.

```console
$ cargo apk r -p glutin_examples --example android
```

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

### Create Display and Window with OpenGL Context in Rust

Source: https://context7.com/rust-windowing/glutin/llms.txt

This Rust code demonstrates the process of initializing a display and creating a window with an OpenGL context using glutin and winit. It configures framebuffer requirements, selects an appropriate OpenGL configuration, creates a context with fallback strategies, sets up a window surface, makes the context current, and enables vsync. It also includes basic window event handling for resizing and redrawing.

```rust
use glutin::config::ConfigTemplateBuilder;
use glutin::context::{ContextApi, ContextAttributesBuilder, Version};
use glutin::display::GetGlDisplay;
use glutin::prelude::*;
use glutin::surface::{Surface, SwapInterval, WindowSurface};
use glutin_winit::{DisplayBuilder, GlWindow};
use std::num::NonZeroU32;
use winit::application::ApplicationHandler;
use winit::event::{WindowEvent, WindowId};
use winit::event_loop::ActiveEventLoop;
use winit::window::Window;

struct App {
    state: Option<AppState>,
}

struct AppState {
    gl_surface: Surface<WindowSurface>,
    gl_context: glutin::context::PossiblyCurrentContext,
    window: Window,
}

impl ApplicationHandler for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        // 1. Configure framebuffer requirements
        let template = ConfigTemplateBuilder::new()
            .with_alpha_size(8)
            .with_depth_size(24)
            .with_stencil_size(8)
            .build();

        // 2. Create display and window together
        let display_builder = DisplayBuilder::new();

        let (window, gl_config) = display_builder
            .build(event_loop, template, |configs| {
                // Pick config with best multisampling
                configs.reduce(|a, b| {
                    if b.num_samples() > a.num_samples() { b } else { a }
                }).unwrap()
            })
            .unwrap();

        let window = window.unwrap();

        // 3. Create OpenGL context with fallback strategy
        let raw_window_handle = window.window_handle().ok().map(|h| h.as_raw());
        let context_attributes = ContextAttributesBuilder::new()
            .with_context_api(ContextApi::OpenGl(Some(Version::new(3, 3))))
            .build(raw_window_handle);

        let fallback_attributes = ContextAttributesBuilder::new()
            .with_context_api(ContextApi::Gles(None))
            .build(raw_window_handle);

        let gl_display = gl_config.display();
        let not_current_context = unsafe {
            gl_display.create_context(&gl_config, &context_attributes) 
                .unwrap_or_else(|_| {
                    gl_display.create_context(&gl_config, &fallback_attributes)
                        .expect("Failed to create context")
                })
        };

        // 4. Create window surface
        let attrs = window.build_surface_attributes(Default::default()).unwrap();
        let gl_surface = unsafe {
            gl_config.display().create_window_surface(&gl_config, &attrs).unwrap()
        };

        // 5. Make context current
        let gl_context = not_current_context.make_current(&gl_surface).unwrap();

        // 6. Enable vsync
        gl_surface.set_swap_interval(
            &gl_context,
            SwapInterval::Wait(NonZeroU32::new(1).unwrap())
        ).ok();

        // 7. Load OpenGL functions (using gl_generator crate)
        let gl = gl::Gl::load_with(|symbol| {
            let symbol = std::ffi::CString::new(symbol).unwrap();
            gl_display.get_proc_address(symbol.as_c_str()).cast()
        });

        self.state = Some(AppState { gl_surface, gl_context, window });
    }

    fn window_event(&mut self, event_loop: &ActiveEventLoop,
                    _id: WindowId, event: WindowEvent) {
        match event {
            WindowEvent::Resized(size) => {
                if let Some(state) = &self.state {
                    if let (Some(w), Some(h)) = (
                        NonZeroU32::new(size.width),
                        NonZeroU32::new(size.height)
                    ) {
                        state.gl_surface.resize(&state.gl_context, w, h);
                    }
                }
            }
            WindowEvent::RedrawRequested => {
                if let Some(state) = &self.state {
                    // Render OpenGL content here
                    state.gl_surface.swap_buffers(&state.gl_context).unwrap();
                }
            }
            WindowEvent::CloseRequested => event_loop.exit(),
            _ => (),
        }
    }
}

```

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

### Create Glutin Display and Select Config (Rust)

Source: https://context7.com/rust-windowing/glutin/llms.txt

This snippet demonstrates how to create a `Display` object from a `winit` window's display handle and then find and select the best `Config` based on specified criteria. It includes setting color buffer types, depth and stencil sizes, multisampling, and API preferences.

```rust
use glutin::config::{Api, ColorBufferType, ConfigSurfaceTypes, ConfigTemplateBuilder};
use glutin::display::{Display, DisplayApiPreference};
use glutin::prelude::*;
use raw_window_handle::{HasDisplayHandle, RawDisplayHandle};

fn create_display_and_config(window: &winit::window::Window)
    -> (Display, glutin::config::Config)
{
    // Get raw display handle from winit
    let display_handle = window.display_handle().unwrap().as_raw();

    // Create display with API preference
    let preference = DisplayApiPreference::EglThenGlx(Box::new(|_| {}));
    let display = unsafe {
        Display::new(display_handle, preference).expect("Failed to create display")
    };

    println!("Display version: {}", display.version_string());
    println!("Supported features: {:?}", display.supported_features());

    // Build configuration template
    let raw_window_handle = window.window_handle().ok().map(|h| h.as_raw());
    let template = ConfigTemplateBuilder::new()
        .with_buffer_type(ColorBufferType::Rgb {
            r_size: 8, g_size: 8, b_size: 8
        })
        .with_alpha_size(8)
        .with_depth_size(24)
        .with_stencil_size(8)
        .with_multisampling(4)  // 4x MSAA
        .with_transparency(true)
        .with_api(Api::OPENGL | Api::GLES3)
        .with_surface_type(ConfigSurfaceTypes::WINDOW)
        .compatible_with_native_window(raw_window_handle.unwrap())
        .prefer_hardware_accelerated(Some(true))
        .build();

    // Find matching configs
    let mut configs: Vec<_> = unsafe {
        display.find_configs(template).unwrap().collect()
    };

    // Select best config
    let config = configs.into_iter()
        .max_by_key(|c| {
            let samples = c.num_samples();
            let hardware = c.hardware_accelerated() as u8;
            let srgb = c.srgb_capable() as u8;
            (hardware, samples, srgb)
        })
        .expect("No suitable config found");

    println!("Selected config:");
    println!("  Color buffer: {:?}", config.color_buffer_type());
    println!("  Alpha: {} bits", config.alpha_size());
    println!("  Depth: {} bits", config.depth_size());
    println!("  Stencil: {} bits", config.stencil_size());
    println!("  Samples: {}", config.num_samples());
    println!("  Hardware accelerated: {}", config.hardware_accelerated());
    println!("  sRGB capable: {}", config.srgb_capable());

    (display, config)
}
```

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

### Create and Manage Glutin Surfaces (Rust)

Source: https://context7.com/rust-windowing/glutin/llms.txt

This Rust code snippet illustrates the creation and management of window and pbuffer surfaces using Glutin. It covers setting up surface attributes, associating them with a window or for offscreen rendering, configuring swap intervals (like VSync), performing buffer swaps, and handling window resize events. It requires the `glutin` and `winit` crates, along with OpenGL bindings.

```rust
use glutin::context::PossiblyCurrentContext;
use glutin::display::GlDisplay;
use glutin::surface::{
    GlSurface,
    PbufferSurface,
    Surface,
    SurfaceAttributesBuilder,
    SwapInterval,
    WindowSurface,
};
use std::num::NonZeroU32;

fn create_and_manage_surfaces(
    display: &impl GlDisplay,
    config: &impl glutin::config::GlConfig,
    window: &winit::window::Window,
    context: &PossiblyCurrentContext,
) {
    // 1. Create window surface
    let window_attrs = window
        .build_surface_attributes(
            SurfaceAttributesBuilder::<WindowSurface>::new()
                .with_srgb(Some(true))
                .build(
                    window.window_handle().unwrap().as_raw(),
                    NonZeroU32::new(800).unwrap(),
                    NonZeroU32::new(600).unwrap(),
                )
        )
        .unwrap();

    let window_surface = unsafe {
        display.create_window_surface(config, &window_attrs).unwrap()
    };

    // Configure swap behavior
    window_surface.set_swap_interval(
        context,
        SwapInterval::Wait(NonZeroU32::new(1).unwrap())  // vsync
    ).ok();

    // 2. Create pbuffer for offscreen rendering
    let pbuffer_attrs = SurfaceAttributesBuilder::<PbufferSurface>::new()
        .with_single_buffer(false)
        .with_largest_pbuffer(false)
        .build(
            NonZeroU32::new(1920).unwrap(),
            NonZeroU32::new(1080).unwrap(),
        );

    let pbuffer_surface = unsafe {
        display.create_pbuffer_surface(config, &pbuffer_attrs).unwrap()
    };

    // Render to window
    context.make_current(&window_surface).unwrap();
    // ... render OpenGL commands ...
    window_surface.swap_buffers(context).unwrap();

    // Switch to pbuffer for offscreen rendering
    context.make_current(&pbuffer_surface).unwrap();
    // ... render to pbuffer ...

    // Handle window resize
    let new_size = window.inner_size();
    if let (Some(w), Some(h)) = (
        NonZeroU32::new(new_size.width),
        NonZeroU32::new(new_size.height),
    ) {
        window_surface.resize(context, w, h);

        // Also update OpenGL viewport
        unsafe {
            gl::Viewport(0, 0, w.get() as i32, h.get() as i32);
        }
    }

    // Query surface properties
    println!("Window surface:");
    println!("  Width: {:?}", window_surface.width());
    println!("  Height: {:?}", window_surface.height());
    println!("  Single buffered: {}", window_surface.is_single_buffered());
    println!("  Buffer age: {}", window_surface.buffer_age());
    println!("  Is current: {}", window_surface.is_current(context));
}

```

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

### Configure X11 Window with Transparency (Rust)

Source: https://context7.com/rust-windowing/glutin/llms.txt

Demonstrates configuring a winit window on X11 to use a specific X11 visual ID, enabling transparency. It retrieves visual information from a Glutin `Config` and applies it to `WindowAttributes` using platform-specific extensions. This is useful for applications requiring visual effects like transparency.

```rust
use glutin::config::Config;
use glutin::platform::x11::X11GlConfigExt;
use winit::platform::x11::WindowAttributesExtX11;
use winit::window::WindowAttributes;

fn configure_x11_window(
    gl_config: &Config,
    window_attrs: WindowAttributes,
) -> WindowAttributes {
    // Get X11 visual info from OpenGL config
    if let Some(visual_info) = gl_config.x11_visual() {
        println!("X11 Visual ID: {}", visual_info.visual_id());

        // Check for transparency support
        if visual_info.supports_transparency() {
            println!("Visual supports transparency");

            // Configure winit window to use this visual
            return window_attrs
                .with_x11_visual(visual_info.visual_id() as _)
                .with_transparent(true);
        }
    }

    window_attrs
}

// Complete example with transparent window
fn create_transparent_window_x11(
    event_loop: &winit::event_loop::ActiveEventLoop,
) -> (winit::window::Window, Config) {
    use glutin::config::ConfigTemplateBuilder;
    use glutin::display::GetGlDisplay;
    use glutin_winit::DisplayBuilder;

    // Request transparency in config
    let template = ConfigTemplateBuilder::new()
        .with_transparency(true)
        .with_alpha_size(8)
        .build();

    let display_builder = DisplayBuilder::new();

    let (window, config) = display_builder
        .build(
            event_loop,
            template,
            |mut configs| {
                // Prefer configs with transparency
                configs
                    .find(|c| c.supports_transparency().unwrap_or(false))
                    .or_else(|| configs.next())
                    .unwrap()
            },
        )
        .unwrap();

    let mut window = window.unwrap();

    // Apply X11 visual if available
    if let Some(visual_info) = config.x11_visual() {
        // Note: Visual must be set before window creation
        // This example shows the concept; actual implementation
        // requires setting visual during window creation
        println!("Using X11 visual: {}", visual_info.visual_id());
    }

    (window, config)
}

```

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

### Create Legacy OpenGL Context with Compatibility Profile (Rust)

Source: https://context7.com/rust-windowing/glutin/llms.txt

Demonstrates creating an OpenGL context using the compatibility profile, suitable for legacy OpenGL features. This is achieved by specifying version 2.1 and `GlProfile::Compatibility`. The function returns a non-current OpenGL context.

```rust
use glutin::config::Config;
use glutin::context::{
    ContextApi, ContextAttributesBuilder, GlProfile,
    NotCurrentGlContext
};
use glutin::display::GlDisplay;

// Context with compatibility profile for legacy OpenGL
fn create_legacy_context(
    display: &impl GlDisplay,
    config: &Config,
    window_handle: Option<raw_window_handle::RawWindowHandle>,
) -> impl NotCurrentGlContext {
    let attrs = ContextAttributesBuilder::new()
        .with_context_api(ContextApi::OpenGl(Some(Version::new(2, 1))))
        .with_profile(GlProfile::Compatibility)
        .build(window_handle);

    unsafe {
        display.create_context(config, &attrs)
            .expect("Failed to create legacy context")
    }
}

```

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

### Create OpenGL Contexts with Sharing Attributes (Rust)

Source: https://context7.com/rust-windowing/glutin/llms.txt

Demonstrates creating two OpenGL contexts, a primary and a secondary, where the secondary context shares resources (textures, buffers) with the primary. This is useful for offloading rendering tasks or managing resources efficiently. It requires the `glutin` and `raw_window_handle` crates.

```rust
use glutin::config::Config;
use glutin::context::{
    ContextApi, ContextAttributesBuilder, GlProfile,
    NotCurrentGlContext, PossiblyCurrentGlContext, Priority, Robustness, Version
};
use glutin::display::GlDisplay;

fn create_contexts_with_sharing(
    display: &impl GlDisplay,
    config: &Config,
    window_handle: Option<raw_window_handle::RawWindowHandle>,
) -> (impl PossiblyCurrentGlContext, impl NotCurrentGlContext) {
    // Primary context with full features
    let primary_attrs = ContextAttributesBuilder::new()
        .with_context_api(ContextApi::OpenGl(Some(Version::new(4, 5))))
        .with_profile(GlProfile::Core)
        .with_debug(true)
        .with_robustness(Robustness::RobustLoseContextOnReset)
        .with_priority(Priority::High)
        .build(window_handle);

    let primary_context = unsafe {
        display.create_context(config, &primary_attrs)
            .expect("Failed to create primary context")
    };

    // Make primary current (required before sharing)
    let primary_context = primary_context
        .make_current_surfaceless()
        .expect("Failed to make primary current");

    // Secondary context that shares resources with primary
    let shared_attrs = ContextAttributesBuilder::new()
        .with_context_api(ContextApi::OpenGl(Some(Version::new(4, 5))))
        .with_profile(GlProfile::Core)
        .with_sharing(&primary_context)  // Share textures/buffers
        .build(window_handle);

    let secondary_context = unsafe {
        display.create_context(config, &shared_attrs)
            .expect("Failed to create shared context")
    };

    // Query context properties
    println!("Primary context API: {:?}", primary_context.context_api());
    println!("Primary priority: {:?}", primary_context.priority());

    (primary_context, secondary_context)
}

```

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

### Android Lifecycle Management in Rust using Glutin

Source: https://context7.com/rust-windowing/glutin/llms.txt

Handles Android lifecycle events for creating and destroying OpenGL surfaces. It reuses the GL context across suspend/resume cycles and recreates the surface when the window is available. Dependencies include 'winit' and 'glutin'.

```rust
use winit::application::ApplicationHandler;
use winit::event_loop::{ActiveEventLoop, EventLoop};
use glutin::context::{NotCurrentContext, PossiblyCurrentContext};
use glutin::surface::{Surface, WindowSurface};

struct AndroidApp {
    // Context stays alive across suspend/resume
    gl_context: Option<NotCurrentContext>,

    // Surface and window destroyed on suspend
    state: Option<ActiveState>,
}

struct ActiveState {
    window: winit::window::Window,
    gl_surface: Surface<WindowSurface>,
    gl_context: PossiblyCurrentContext,
}

impl ApplicationHandler for AndroidApp {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        println!("Android window available - creating surface");

        // Window now available, create or recreate surface
        let (window, config) = create_window_and_config(event_loop);

        let gl_context = if let Some(not_current) = self.gl_context.take() {
            // Reuse existing context
            not_current
        } else {
            // Create new context on first launch
            let display = config.display();
            let attrs = glutin::context::ContextAttributesBuilder::new()
                .with_context_api(glutin::context::ContextApi::Gles(None))
                .build(window.window_handle().ok().map(|h| h.as_raw()));

            unsafe {
                display.create_context(&config, &attrs)
                    .expect("Failed to create context")
            }
        };

        // Create new surface
        let attrs = window.build_surface_attributes(Default::default()).unwrap();
        let gl_surface = unsafe {
            config.display() 
                .create_window_surface(&config, &attrs)
                .expect("Failed to create surface")
        };

        // Make current
        let gl_context = gl_context.make_current(&gl_surface)
            .expect("Failed to make context current");

        self.state = Some(ActiveState {
            window,
            gl_surface,
            gl_context,
        });
    }

    fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
        println!("Android window destroyed - destroying surface");

        // Must destroy surface when window is removed
        if let Some(state) = self.state.take() {
            // Make context not current and preserve it
            self.gl_context = Some(
                state.gl_context
                    .make_not_current()
                    .expect("Failed to release context")
            );

            // state.gl_surface and state.window are dropped here
        }
    }

    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        _id: winit::event::WindowId,
        event: winit::event::WindowEvent,
    ) {
        if let Some(state) = &self.state {
            match event {
                winit::event::WindowEvent::RedrawRequested => {
                    // Render frame
                    unsafe {
                        gl::Clear(gl::COLOR_BUFFER_BIT);
                        // ... rendering ...
                    }
                    state.gl_surface.swap_buffers(&state.gl_context).unwrap();
                    state.window.request_redraw();
                }
                _ => (),
            }
        }
    }
}

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app: winit::platform::android::activity::AndroidApp) {
    use winit::platform::android::EventLoopBuilderExtAndroid;

    let event_loop = EventLoop::builder()
        .with_android_app(app)
        .build()
        .unwrap();

    let mut app = AndroidApp {
        gl_context: None,
        state: None,
    };

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

fn create_window_and_config(
    event_loop: &ActiveEventLoop
) -> (winit::window::Window, glutin::config::Config) {
    // Implementation details omitted
    unimplemented!()
}

```

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

### Offscreen EGL Rendering with Glutins

Source: https://context7.com/rust-windowing/glutin/llms.txt

This Rust code demonstrates offscreen rendering using EGL devices provided by glutin. It initializes EGL, creates a headless context, sets up a framebuffer, renders to it, and reads back the pixel data. This functionality is useful for server-side rendering and automated testing where a graphical interface is not available. It depends on the `glutin` and `glow` crates.

```rust
use glutin::api::egl::device::Device;
use glutin::api::egl::display::Display;
use glutin::config::{ConfigSurfaceTypes, ConfigTemplateBuilder};
use glutin::context::{ContextApi, ContextAttributesBuilder};
use glutin::display::GlDisplay;
use std::ffi::CString;

fn offscreen_egl_rendering() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    // 1. Query available EGL devices
    let devices: Vec<_> = Device::query_devices()
        .expect("Failed to query EGL devices")
        .collect();

    if devices.is_empty() {
        return Err("No EGL devices available".into());
    }

    println!("Found {} EGL devices", devices.len());
    let device = &devices[0];

    // 2. Create display from device (no windowing system needed)
    let display = unsafe {
        Display::with_device(device, None)
            .expect("Failed to create EGL display from device")
    };

    println!("EGL version: {}", display.version_string());

    // 3. Configure for offscreen rendering (no surface types needed)
    let template = ConfigTemplateBuilder::new()
        .with_alpha_size(8)
        .with_depth_size(24)
        .with_surface_type(ConfigSurfaceTypes::empty())  // Surfaceless
        .build();

    let config = unsafe {
        display.find_configs(template)?
            .next()
            .ok_or("No suitable configs")?
    };

    // 4. Create context without window
    let context_attrs = ContextAttributesBuilder::new()
        .with_context_api(ContextApi::Gles(None))
        .build(None);  // No window handle

    let context = unsafe {
        display.create_context(&config, &context_attrs)?
    };

    // 5. Make current without surface
    let context = context.make_current_surfaceless()?;

    // 6. Load OpenGL ES functions
    let gl = glow::Context::from_loader_function(|name| {
        let name = CString::new(name).unwrap();
        display.get_proc_address(name.as_c_str())
    });

    // 7. Create framebuffer for offscreen rendering
    unsafe {
        let framebuffer = gl.create_framebuffer()?;
        let renderbuffer = gl.create_renderbuffer()?;

        gl.bind_framebuffer(glow::FRAMEBUFFER, Some(framebuffer));
        gl.bind_renderbuffer(glow::RENDERBUFFER, Some(renderbuffer));

        // Allocate storage
        gl.renderbuffer_storage(
            glow::RENDERBUFFER,
            glow::RGBA8,
            1920,
            1080,
        );

        gl.framebuffer_renderbuffer(
            glow::FRAMEBUFFER,
            glow::COLOR_ATTACHMENT0,
            glow::RENDERBUFFER,
            Some(renderbuffer),
        );

        // Check framebuffer completeness
        let status = gl.check_framebuffer_status(glow::FRAMEBUFFER);
        if status != glow::FRAMEBUFFER_COMPLETE {
            return Err(format!("Framebuffer incomplete: {:x}", status).into());
        }

        // 8. Render
        gl.viewport(0, 0, 1920, 1080);
        gl.clear_color(0.2, 0.4, 0.8, 1.0);
        gl.clear(glow::COLOR_BUFFER_BIT);

        // ... additional rendering ...

        // 9. Read pixels
        let mut pixels = vec![0u8; 1920 * 1080 * 4];
        gl.finish();
        gl.read_pixels(
            0, 0, 1920, 1080,
            glow::RGBA,
            glow::UNSIGNED_BYTE,
            glow::PixelPackData::Slice(&mut pixels),
        );

        // Cleanup
        gl.delete_framebuffer(framebuffer);
        gl.delete_renderbuffer(renderbuffer);

        Ok(pixels)
    }
}

```

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

### Thread-Safe OpenGL Context Transfer in Rust (glutin)

Source: https://context7.com/rust-windowing/glutin/llms.txt

Demonstrates transferring an OpenGL context between threads for multi-threaded rendering. It involves making the context non-current, moving it to a new thread, and then making it current on that thread. The `Send` trait is implemented for `RenderState` to allow safe transfer.

```rust
use glutin::context::{NotCurrentContext, PossiblyCurrentContext};
use glutin::display::GetGlDisplay;
use glutin::surface::{Surface, WindowSurface};
use std::sync::{Arc, Mutex};
use std::thread;

struct RenderState {
    context: PossiblyCurrentContext,
    surface: Surface<WindowSurface>,
}

unsafe impl Send for RenderState {}

fn multithreaded_rendering() {
    // Initial setup on main thread
    let (context, surface) = setup_opengl(); // returns (PossiblyCurrentContext, Surface)

    // Make context not current to transfer to another thread
    let not_current = context.make_not_current()
        .expect("Failed to release context");

    let surface_clone = surface; // Surface is Send

    // Spawn render thread
    let render_thread = thread::spawn(move || {
        // Make context current on render thread
        let context = not_current
            .make_current(&surface_clone)
            .expect("Failed to make context current on render thread");

        // Render loop
        for frame in 0..60 {
            // OpenGL rendering commands
            unsafe {
                gl::ClearColor(
                    (frame as f32 / 60.0).sin(),
                    0.3,
                    0.3,
                    1.0
                );
                gl::Clear(gl::COLOR_BUFFER_BIT);
            }

            surface_clone.swap_buffers(&context)
                .expect("Failed to swap buffers");

            thread::sleep(std::time::Duration::from_millis(16));
        }

        // Release context before returning to main thread
        context.make_not_current()
            .expect("Failed to release context")
    });

    // Wait for render thread to finish
    let not_current = render_thread.join().unwrap();

    // Can now use context on main thread again
    let context = not_current.treat_as_possibly_current();
}

// Alternative: Arc<Mutex> pattern for dynamic switching
fn dynamic_thread_switching(
    initial_context: PossiblyCurrentContext,
    surface: Surface<WindowSurface>,
) {
    let render_state = Arc::new(Mutex::new(RenderState {
        context: initial_context,
        surface,
    }));

    let threads: Vec<_> = (0..2).map(|thread_id| {
        let state = Arc::clone(&render_state);
        thread::spawn(move || {
            for _ in 0..10 {
                let mut state = state.lock().unwrap();

                // Make current on this thread
                state.context.make_current(&state.surface)
                    .expect("Failed to make current");

                // Render frame
                unsafe {
                    gl::ClearColor(thread_id as f32, 0.5, 0.5, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT);
                }
                state.surface.swap_buffers(&state.context).unwrap();

                // Release for other thread
                state.context.make_not_current_in_place()
                    .expect("Failed to release");

                drop(state); // Release mutex
                thread::sleep(std::time::Duration::from_millis(16));
            }
        })
    }).collect();

    for thread in threads {
        thread.join().unwrap();
    }
}

fn setup_opengl() -> (PossiblyCurrentContext, Surface<WindowSurface>) {
    // Implementation details omitted for brevity
    unimplemented!();
}

```

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