Having trouble adapting minimal-egui example to my project

[njneeteson]

I have a very simple hobby project that I'm working on using the pixels crate. It's not that complicated - it's kind of like a blend of the minimal-winit and minimal-egui examples but with a more complex World struct / implementation.

However I am having trouble incorporating egui into my project.. I'm getting errors from the gui component that I don't understand because I haven't changed a single line from the minimal-egui gui.rs file (which I have checked, compiles and runs on my computer).

Mostly it seems like some functions are expecting to get inputs with types that come from the egui_wgpu crate but instead the inputs have similarly named types that come from the pixels crate. Again I did not change anything in gui.rs, and in main.rs the event loop is defined pretty much as close to the example as I could get it when troubleshooting. I also made sure my dependencies were the same as the minimal-egui example with the exception of adding kd-tree, rayon, and rand.

Below I have pasted in the terminal output, main.rs, gui.rs, and Cargo.toml, in case it's useful to help. I really appreciate anyone who takes the time to read and offer advice / help - I'm pretty stuck. Thanks.

Compiling particle_life v0.1.0 (C:\Users\njnee\RustProjects\particle_life)
error[E0308]: arguments to this function are incorrect
    --> src\gui.rs:46:24
     |
46   |         let renderer = Renderer::new(pixels.device(), pixels.render_texture_format(), None, 1);
     |                        ^^^^^^^^^^^^^ ---------------  ------------------------------ expected `egui_wgpu::wgpu::TextureFormat`, found `pixels::wgpu::TextureFormat`
     |                                      |
     |                                      expected `egui_wgpu::wgpu::Device`, found `pixels::wgpu::Device`
     |
     = note: `pixels::wgpu::Device` and `egui_wgpu::wgpu::Device` have similar names, but are actually distinct types
note: `pixels::wgpu::Device` is defined in crate `wgpu`
    --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:117:1
     |
117  | pub struct Device {
     | ^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::Device` is defined in crate `wgpu`
    --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:160:1
     |
160  | pub struct Device {
     | ^^^^^^^^^^^^^^^^^
     = note: perhaps two different versions of crate `wgpu` are being used?
     = note: `pixels::wgpu::TextureFormat` and `egui_wgpu::wgpu::TextureFormat` have similar names, but are actually distinct types
note: `pixels::wgpu::TextureFormat` is defined in crate `wgpu_types`
    --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-types-0.16.1\src\lib.rs:1907:1
     |
1907 | pub enum TextureFormat {
     | ^^^^^^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::TextureFormat` is defined in crate `wgpu_types`
    --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-types-0.17.0\src\lib.rs:1940:1
     |
1940 | pub enum TextureFormat {
     | ^^^^^^^^^^^^^^^^^^^^^^
     = note: perhaps two different versions of crate `wgpu_types` are being used?
note: associated function defined here
    --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\egui-wgpu-0.23.0\src\renderer.rs:180:12
     |
180  |     pub fn new(
     |            ^^^

error[E0308]: arguments to this method are incorrect
   --> src\gui.rs:103:18
    |
103 |                 .update_texture(&context.device, &context.queue, *id, image_delta);
    |                  ^^^^^^^^^^^^^^ ---------------  -------------- expected `egui_wgpu::wgpu::Queue`, found `pixels::wgpu::Queue`
    |                                 |
    |                                 expected `egui_wgpu::wgpu::Device`, found `pixels::wgpu::Device`
    |
    = note: `pixels::wgpu::Device` and `egui_wgpu::wgpu::Device` have similar names, but are actually distinct types
note: `pixels::wgpu::Device` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:117:1
    |
117 | pub struct Device {
    | ^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::Device` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:160:1
    |
160 | pub struct Device {
    | ^^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
    = note: `pixels::wgpu::Queue` and `egui_wgpu::wgpu::Queue` have similar names, but are actually distinct types
note: `pixels::wgpu::Queue` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:715:1
    |
715 | pub struct Queue {
    | ^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::Queue` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:884:1
    |
884 | pub struct Queue {
    | ^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
note: method defined here
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\egui-wgpu-0.23.0\src\renderer.rs:487:12
    |
487 |     pub fn update_texture(
    |            ^^^^^^^^^^^^^^

error[E0308]: arguments to this method are incorrect
   --> src\gui.rs:105:23
    |
105 |         self.renderer.update_buffers(
    |                       ^^^^^^^^^^^^^^
106 |             &context.device,
    |             --------------- expected `egui_wgpu::wgpu::Device`, found `pixels::wgpu::Device`
107 |             &context.queue,
    |             -------------- expected `egui_wgpu::wgpu::Queue`, found `pixels::wgpu::Queue`
108 |             encoder,
    |             ------- expected `egui_wgpu::wgpu::CommandEncoder`, found `pixels::wgpu::CommandEncoder`
    |
    = note: `pixels::wgpu::Device` and `egui_wgpu::wgpu::Device` have similar names, but are actually distinct types
note: `pixels::wgpu::Device` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:117:1
    |
117 | pub struct Device {
    | ^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::Device` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:160:1
    |
160 | pub struct Device {
    | ^^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
    = note: `pixels::wgpu::Queue` and `egui_wgpu::wgpu::Queue` have similar names, but are actually distinct types
note: `pixels::wgpu::Queue` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:715:1
    |
715 | pub struct Queue {
    | ^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::Queue` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:884:1
    |
884 | pub struct Queue {
    | ^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
    = note: `pixels::wgpu::CommandEncoder` and `egui_wgpu::wgpu::CommandEncoder` have similar names, but are actually distinct types
note: `pixels::wgpu::CommandEncoder` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:595:1
    |
595 | pub struct CommandEncoder {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::CommandEncoder` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:743:1
    |
743 | pub struct CommandEncoder {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
note: method defined here
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\egui-wgpu-0.23.0\src\renderer.rs:752:12
    |
752 |     pub fn update_buffers(
    |            ^^^^^^^^^^^^^^

error[E0308]: mismatched types
   --> src\gui.rs:129:25
    |
129 |                 .render(&mut rpass, &self.paint_jobs, &self.screen_descriptor);
    |                  ------ ^^^^^^^^^^ expected `egui_wgpu::wgpu::RenderPass<'_>`, found `pixels::wgpu::RenderPass<'_>`
    |                  |
    |                  arguments to this method are incorrect
    |
    = note: `pixels::wgpu::RenderPass<'_>` and `egui_wgpu::wgpu::RenderPass<'_>` have similar names, but are actually distinct types
note: `pixels::wgpu::RenderPass<'_>` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.16.3\src\lib.rs:619:1
    |
619 | pub struct RenderPass<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
note: `egui_wgpu::wgpu::RenderPass<'_>` is defined in crate `wgpu`
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\wgpu-0.17.2\src\lib.rs:774:1
    |
774 | pub struct RenderPass<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: perhaps two different versions of crate `wgpu` are being used?
note: method defined here
   --> C:\Users\njnee\.cargo\registry\src\index.crates.io-6f17d22bba15001f\egui-wgpu-0.23.0\src\renderer.rs:360:12
    |
360 |     pub fn render<'rp>(
    |            ^^^^^^

For more information about this error, try `rustc --explain E0308`.
error: could not compile `particle_life` (bin "particle_life") due to 4 previous errors

main.rs:

use error_iter::ErrorIter as _;
use log::error;
use pixels::{Error, Pixels, SurfaceTexture};
use winit::dpi::LogicalSize;
use winit::event::{Event, VirtualKeyCode};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
use winit_input_helper::WinitInputHelper;

mod world;
use crate::world::World;

mod gui;
use crate::gui::Framework;

const WIDTH: u32 = 500;
const HEIGHT: u32 = 300;


fn log_error<E: std::error::Error + 'static>(method_name: &str, err: E) {
    error!("{method_name}() failed: {err}");
    for source in err.sources().skip(1) {
        error!("  Caused by: {source}");
    }
}


fn main() -> Result<(), Error> {

    env_logger::init();
    let event_loop = EventLoop::new();
    let mut input = WinitInputHelper::new();
    let window = {
        let size = LogicalSize::new(WIDTH as f64, HEIGHT as f64);
        WindowBuilder::new()
            .with_title("Particle Life")
            .with_inner_size(size)
            .with_min_inner_size(size)
            .build(&event_loop)
            .unwrap()
    };

    let (mut pixels, mut framework) = {
        let window_size = window.inner_size();
        let scale_factor = window.scale_factor() as f32;
        let surface_texture = SurfaceTexture::new(window_size.width, window_size.height, &window);
        let pixels = Pixels::new(WIDTH / 2, HEIGHT / 2, surface_texture)?;
        let framework = Framework::new(
            &event_loop,
            window_size.width,
            window_size.height,
            scale_factor,
            &pixels
        );
        (pixels, framework)
    };
    
    let mut world = World::new(WIDTH / 2, HEIGHT / 2);

    event_loop.run(move |event, _, control_flow| {

        
        // handle input events
        if input.update(&event) {

            // close events
            if input.key_pressed(VirtualKeyCode::Escape) || input.close_requested() {
                *control_flow = ControlFlow::Exit;
                return;
            }

            // Update the scale factor
            if let Some(scale_factor) = input.scale_factor() {
                framework.scale_factor(scale_factor);
            }

            // resizing the window
            if let Some(size) = input.window_resized() {
                // update the surface, the buffer, and the dimensions of the world
                if let Err(_err) = pixels.resize_surface(size.width, size.height) {
                    *control_flow = ControlFlow::Exit;
                    return;
                }
                if let Err(_err) = pixels.resize_buffer(size.width / 2, size.height / 2) {
                    *control_flow = ControlFlow::Exit;
                    return;
                }
                world.configuration.width = size.width / 2;
                world.configuration.height = size.height / 2;
                framework.resize(size.width, size.height);
            }

            // reset/randomize everything
            if input.key_pressed(VirtualKeyCode::Space) {
                world.reset_particles();
                world.reset_attraction_matrix();
                world.reset_colors();
            }

            // Update the world and request redraw
            world.update(input.mouse_held(0_usize), input.mouse_held(1_usize), input.mouse());
            window.request_redraw();

        }

        /*
        // Draw current frame
        if let Event::RedrawRequested(_) = event {
            world.draw(pixels.frame_mut());
            if let Err(_err) = pixels.render() {
                *control_flow = ControlFlow::Exit;
                return;
            }
        }
        */

        match event {
            Event::WindowEvent { event, .. } => {
                // Update egui inputs
                framework.handle_event(&event);
            }
            // Draw the current frame
            Event::RedrawRequested(_) => {
                // Draw the world
                world.draw(pixels.frame_mut());

                // Prepare egui
                framework.prepare(&window);

                // Render everything together
                let render_result = pixels.render_with(|encoder, render_target, context| {
                    // Render the world texture
                    context.scaling_renderer.render(encoder, render_target);

                    // Render egui
                    framework.render(encoder, render_target, context);

                    Ok(())
                });

                // Basic error handling
                if let Err(err) = render_result {
                    log_error("pixels.render", err);
                    *control_flow = ControlFlow::Exit;
                }
            }
            _ => (),
        }
    });
}

gui.rs:

use egui::{ClippedPrimitive, Context, TexturesDelta};
use egui_wgpu::renderer::{Renderer, ScreenDescriptor};
use pixels::{wgpu, PixelsContext};
use winit::event_loop::EventLoopWindowTarget;
use winit::window::Window;

/// Manages all state required for rendering egui over `Pixels`.
pub(crate) struct Framework {
    // State for egui.
    egui_ctx: Context,
    egui_state: egui_winit::State,
    screen_descriptor: ScreenDescriptor,
    renderer: Renderer,
    paint_jobs: Vec<ClippedPrimitive>,
    textures: TexturesDelta,

    // State for the GUI
    gui: Gui,
}

/// Example application state. A real application will need a lot more state than this.
struct Gui {
    /// Only show the egui window when true.
    window_open: bool,
}

impl Framework {
    /// Create egui.
    pub(crate) fn new<T>(
        event_loop: &EventLoopWindowTarget<T>,
        width: u32,
        height: u32,
        scale_factor: f32,
        pixels: &pixels::Pixels,
    ) -> Self {
        let max_texture_size = pixels.device().limits().max_texture_dimension_2d as usize;

        let egui_ctx = Context::default();
        let mut egui_state = egui_winit::State::new(event_loop);
        egui_state.set_max_texture_side(max_texture_size);
        egui_state.set_pixels_per_point(scale_factor);
        let screen_descriptor = ScreenDescriptor {
            size_in_pixels: [width, height],
            pixels_per_point: scale_factor,
        };
        let renderer = Renderer::new(pixels.device(), pixels.render_texture_format(), None, 1);
        let textures = TexturesDelta::default();
        let gui = Gui::new();

        Self {
            egui_ctx,
            egui_state,
            screen_descriptor,
            renderer,
            paint_jobs: Vec::new(),
            textures,
            gui,
        }
    }

    /// Handle input events from the window manager.
    pub(crate) fn handle_event(&mut self, event: &winit::event::WindowEvent) {
        let _ = self.egui_state.on_event(&self.egui_ctx, event);
    }

    /// Resize egui.
    pub(crate) fn resize(&mut self, width: u32, height: u32) {
        if width > 0 && height > 0 {
            self.screen_descriptor.size_in_pixels = [width, height];
        }
    }

    /// Update scaling factor.
    pub(crate) fn scale_factor(&mut self, scale_factor: f64) {
        self.screen_descriptor.pixels_per_point = scale_factor as f32;
    }

    /// Prepare egui.
    pub(crate) fn prepare(&mut self, window: &Window) {
        // Run the egui frame and create all paint jobs to prepare for rendering.
        let raw_input = self.egui_state.take_egui_input(window);
        let output = self.egui_ctx.run(raw_input, |egui_ctx| {
            // Draw the demo application.
            self.gui.ui(egui_ctx);
        });

        self.textures.append(output.textures_delta);
        self.egui_state
            .handle_platform_output(window, &self.egui_ctx, output.platform_output);
        self.paint_jobs = self.egui_ctx.tessellate(output.shapes);
    }

    /// Render egui.
    pub(crate) fn render(
        &mut self,
        encoder: &mut wgpu::CommandEncoder,
        render_target: &wgpu::TextureView,
        context: &PixelsContext,
    ) {
        // Upload all resources to the GPU.
        for (id, image_delta) in &self.textures.set {
            self.renderer
                .update_texture(&context.device, &context.queue, *id, image_delta);
        }
        self.renderer.update_buffers(
            &context.device,
            &context.queue,
            encoder,
            &self.paint_jobs,
            &self.screen_descriptor,
        );

        // Render egui with WGPU
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("egui"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: render_target,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: true,
                    },
                })],
                depth_stencil_attachment: None,
            });

            self.renderer
                .render(&mut rpass, &self.paint_jobs, &self.screen_descriptor);
        }

        // Cleanup
        let textures = std::mem::take(&mut self.textures);
        for id in &textures.free {
            self.renderer.free_texture(id);
        }
    }
}

impl Gui {
    /// Create a `Gui`.
    fn new() -> Self {
        Self { window_open: true }
    }

    /// Create the UI using egui.
    fn ui(&mut self, ctx: &Context) {
        egui::TopBottomPanel::top("menubar_container").show(ctx, |ui| {
            egui::menu::bar(ui, |ui| {
                ui.menu_button("File", |ui| {
                    if ui.button("About...").clicked() {
                        self.window_open = true;
                        ui.close_menu();
                    }
                })
            });
        });

        egui::Window::new("Hello, egui!")
            .open(&mut self.window_open)
            .show(ctx, |ui| {
                ui.label("This example demonstrates using egui with pixels.");
                ui.label("Made with 💖 in San Francisco!");

                ui.separator();

                ui.horizontal(|ui| {
                    ui.spacing_mut().item_spacing.x /= 2.0;
                    ui.label("Learn more about egui at");
                    ui.hyperlink("https://docs.rs/egui");
                });
            });
    }
}

Cargo.toml:

[package]
name = "particle_life"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html


[features]
optimize = ["log/release_max_level_warn"]
default = ["optimize"]

[dependencies]
egui = "0.23"
egui-wgpu = "0.23"
egui-winit = { version = "0.23", default-features = false, features = ["links"] }
env_logger = "0.10"
error-iter = "0.4"
log = "0.4"
pixels = "0.13.0"
winit = "0.28"
winit_input_helper = "0.14"
kd-tree = { version = "0.5.3", features = ["rayon"] }
rand = "0.8.5"
rayon = "1.8.0"

[profile.release]
lto = "fat"
codegen-units = 1
panic = "abort"

[dbalsom]

You've somehow imported wgpu 0.16 and 0.17 simultaneously.

I'd do the following -
cargo clean
cargo update

if build still fails, post the output of
cargo tree

to see where each version of wgpu is being imported

[njneeteson]

Thanks for the answer. cargo clean and then cargo update did not fix it, same build failure, same terminal output.

cargo tree:

particle_life v0.1.0 (C:\Users\njnee\RustProjects\particle_life)
├── egui v0.23.0
│   ├── ahash v0.8.7
│   │   ├── cfg-if v1.0.0
│   │   ├── once_cell v1.19.0
│   │   └── zerocopy v0.7.32
│   │   [build-dependencies]
│   │   └── version_check v0.9.4
│   ├── epaint v0.23.0
│   │   ├── ab_glyph v0.2.23
│   │   │   ├── ab_glyph_rasterizer v0.1.8
│   │   │   └── owned_ttf_parser v0.20.0
│   │   │       └── ttf-parser v0.20.0
│   │   ├── ahash v0.8.7 (*)
│   │   ├── bytemuck v1.14.0
│   │   │   └── bytemuck_derive v1.5.0 (proc-macro)
│   │   │       ├── proc-macro2 v1.0.76
│   │   │       │   └── unicode-ident v1.0.12
│   │   │       ├── quote v1.0.35
│   │   │       │   └── proc-macro2 v1.0.76 (*)
│   │   │       └── syn v2.0.48
│   │   │           ├── proc-macro2 v1.0.76 (*)
│   │   │           ├── quote v1.0.35 (*)
│   │   │           └── unicode-ident v1.0.12
│   │   ├── ecolor v0.23.0
│   │   │   └── bytemuck v1.14.0 (*)
│   │   ├── emath v0.23.0
│   │   │   └── bytemuck v1.14.0 (*)
│   │   ├── log v0.4.20
│   │   ├── nohash-hasher v0.2.0
│   │   └── parking_lot v0.12.1
│   │       ├── lock_api v0.4.11
│   │       │   └── scopeguard v1.2.0
│   │       │   [build-dependencies]
│   │       │   └── autocfg v1.1.0
│   │       └── parking_lot_core v0.9.9
│   │           ├── cfg-if v1.0.0
│   │           ├── smallvec v1.12.0
│   │           └── windows-targets v0.48.5
│   │               └── windows_x86_64_msvc v0.48.5
│   ├── log v0.4.20
│   └── nohash-hasher v0.2.0
├── egui-wgpu v0.23.0
│   ├── bytemuck v1.14.0 (*)
│   ├── epaint v0.23.0 (*)
│   ├── log v0.4.20
│   ├── thiserror v1.0.56
│   │   └── thiserror-impl v1.0.56 (proc-macro)
│   │       ├── proc-macro2 v1.0.76 (*)
│   │       ├── quote v1.0.35 (*)
│   │       └── syn v2.0.48 (*)
│   ├── type-map v0.5.0
│   │   └── rustc-hash v1.1.0
│   └── wgpu v0.17.2
│       ├── arrayvec v0.7.4
│       ├── cfg-if v1.0.0
│       ├── log v0.4.20
│       ├── parking_lot v0.12.1 (*)
│       ├── profiling v1.0.13
│       ├── raw-window-handle v0.5.2
│       ├── smallvec v1.12.0
│       ├── static_assertions v1.1.0
│       ├── wgpu-core v0.17.1
│       │   ├── arrayvec v0.7.4
│       │   ├── bit-vec v0.6.3
│       │   ├── bitflags v2.4.2
│       │   ├── codespan-reporting v0.11.1
│       │   │   ├── termcolor v1.4.1
│       │   │   │   └── winapi-util v0.1.6
│       │   │   │       └── winapi v0.3.9
│       │   │   └── unicode-width v0.1.11
│       │   ├── log v0.4.20
│       │   ├── naga v0.13.0
│       │   │   ├── bit-set v0.5.3
│       │   │   │   └── bit-vec v0.6.3
│       │   │   ├── bitflags v2.4.2
│       │   │   ├── codespan-reporting v0.11.1 (*)
│       │   │   ├── hexf-parse v0.2.1
│       │   │   ├── indexmap v1.9.3
│       │   │   │   └── hashbrown v0.12.3
│       │   │   │   [build-dependencies]
│       │   │   │   └── autocfg v1.1.0
│       │   │   ├── log v0.4.20
│       │   │   ├── num-traits v0.2.17
│       │   │   │   [build-dependencies]
│       │   │   │   └── autocfg v1.1.0
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── spirv v0.2.0+1.5.4
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   └── num-traits v0.2.17 (*)
│       │   │   ├── termcolor v1.4.1 (*)
│       │   │   ├── thiserror v1.0.56 (*)
│       │   │   └── unicode-xid v0.2.4
│       │   ├── parking_lot v0.12.1 (*)
│       │   ├── profiling v1.0.13
│       │   ├── raw-window-handle v0.5.2
│       │   ├── rustc-hash v1.1.0
│       │   ├── smallvec v1.12.0
│       │   ├── thiserror v1.0.56 (*)
│       │   ├── wgpu-hal v0.17.2
│       │   │   ├── arrayvec v0.7.4
│       │   │   ├── ash v0.37.3+1.3.251
│       │   │   │   └── libloading v0.7.4
│       │   │   │       └── winapi v0.3.9
│       │   │   ├── bit-set v0.5.3 (*)
│       │   │   ├── bitflags v2.4.2
│       │   │   ├── d3d12 v0.7.0
│       │   │   │   ├── bitflags v2.4.2
│       │   │   │   ├── libloading v0.8.1
│       │   │   │   │   └── windows-sys v0.48.0
│       │   │   │   │       └── windows-targets v0.48.5 (*)
│       │   │   │   └── winapi v0.3.9
│       │   │   ├── glow v0.12.3
│       │   │   ├── gpu-alloc v0.6.0
│       │   │   │   ├── bitflags v2.4.2
│       │   │   │   └── gpu-alloc-types v0.3.0
│       │   │   │       └── bitflags v2.4.2
│       │   │   ├── gpu-allocator v0.22.0
│       │   │   │   ├── backtrace v0.3.69
│       │   │   │   │   ├── cfg-if v1.0.0
│       │   │   │   │   └── rustc-demangle v0.1.23
│       │   │   │   │   [build-dependencies]
│       │   │   │   │   └── cc v1.0.83
│       │   │   │   ├── log v0.4.20
│       │   │   │   ├── thiserror v1.0.56 (*)
│       │   │   │   ├── winapi v0.3.9
│       │   │   │   └── windows v0.44.0
│       │   │   │       └── windows-targets v0.42.2
│       │   │   │           └── windows_x86_64_msvc v0.42.2
│       │   │   ├── gpu-descriptor v0.2.4
│       │   │   │   ├── bitflags v2.4.2
│       │   │   │   ├── gpu-descriptor-types v0.1.2
│       │   │   │   │   └── bitflags v2.4.2
│       │   │   │   └── hashbrown v0.14.3
│       │   │   │       ├── ahash v0.8.7 (*)
│       │   │   │       └── allocator-api2 v0.2.16
│       │   │   ├── hassle-rs v0.10.0
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   ├── com-rs v0.2.1
│       │   │   │   ├── libloading v0.7.4 (*)
│       │   │   │   ├── thiserror v1.0.56 (*)
│       │   │   │   ├── widestring v1.0.2
│       │   │   │   └── winapi v0.3.9
│       │   │   ├── khronos-egl v4.1.0
│       │   │   │   ├── libc v0.2.152
│       │   │   │   └── libloading v0.7.4 (*)
│       │   │   ├── libloading v0.8.1 (*)
│       │   │   ├── log v0.4.20
│       │   │   ├── naga v0.13.0 (*)
│       │   │   ├── parking_lot v0.12.1 (*)
│       │   │   ├── profiling v1.0.13
│       │   │   ├── range-alloc v0.1.3
│       │   │   ├── raw-window-handle v0.5.2
│       │   │   ├── renderdoc-sys v1.0.0
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── smallvec v1.12.0
│       │   │   ├── thiserror v1.0.56 (*)
│       │   │   ├── wgpu-types v0.17.0
│       │   │   │   └── bitflags v2.4.2
│       │   │   └── winapi v0.3.9
│       │   └── wgpu-types v0.17.0 (*)
│       ├── wgpu-hal v0.17.2 (*)
│       └── wgpu-types v0.17.0 (*)
├── egui-winit v0.23.0
│   ├── egui v0.23.0 (*)
│   ├── log v0.4.20
│   ├── raw-window-handle v0.5.2
│   ├── web-time v0.2.4
│   ├── webbrowser v0.8.12
│   │   ├── log v0.4.20
│   │   └── url v2.5.0
│   │       ├── form_urlencoded v1.2.1
│   │       │   └── percent-encoding v2.3.1
│   │       ├── idna v0.5.0
│   │       │   ├── unicode-bidi v0.3.15
│   │       │   └── unicode-normalization v0.1.22
│   │       │       └── tinyvec v1.6.0
│   │       │           └── tinyvec_macros v0.1.1
│   │       └── percent-encoding v2.3.1
│   └── winit v0.28.7
│       ├── bitflags v1.3.2
│       ├── instant v0.1.12
│       │   └── cfg-if v1.0.0
│       ├── log v0.4.20
│       ├── once_cell v1.19.0
│       ├── raw-window-handle v0.5.2
│       └── windows-sys v0.45.0
│           └── windows-targets v0.42.2 (*)
│       [build-dependencies]
│       └── cfg_aliases v0.1.1
├── env_logger v0.10.2
│   ├── humantime v2.1.0
│   ├── is-terminal v0.4.10
│   │   └── windows-sys v0.52.0
│   │       └── windows-targets v0.52.0
│   │           └── windows_x86_64_msvc v0.52.0
│   ├── log v0.4.20
│   ├── regex v1.10.2
│   │   ├── aho-corasick v1.1.2
│   │   │   └── memchr v2.7.1
│   │   ├── memchr v2.7.1
│   │   ├── regex-automata v0.4.3
│   │   │   ├── aho-corasick v1.1.2 (*)
│   │   │   ├── memchr v2.7.1
│   │   │   └── regex-syntax v0.8.2
│   │   └── regex-syntax v0.8.2
│   └── termcolor v1.4.1 (*)
├── error-iter v0.4.1
├── kd-tree v0.5.3
│   ├── num-traits v0.2.17 (*)
│   ├── ordered-float v3.9.2
│   │   └── num-traits v0.2.17 (*)
│   ├── paste v1.0.14 (proc-macro)
│   ├── pdqselect v0.1.1
│   ├── rayon v1.8.1
│   │   ├── either v1.9.0
│   │   └── rayon-core v1.12.1
│   │       ├── crossbeam-deque v0.8.5
│   │       │   ├── crossbeam-epoch v0.9.18
│   │       │   │   └── crossbeam-utils v0.8.19
│   │       │   └── crossbeam-utils v0.8.19
│   │       └── crossbeam-utils v0.8.19
│   └── typenum v1.17.0
├── log v0.4.20
├── pixels v0.13.0
│   ├── bytemuck v1.14.0 (*)
│   ├── pollster v0.3.0
│   ├── raw-window-handle v0.5.2
│   ├── thiserror v1.0.56 (*)
│   ├── ultraviolet v0.9.2
│   │   └── wide v0.7.13
│   │       ├── bytemuck v1.14.0 (*)
│   │       └── safe_arch v0.7.1
│   │           └── bytemuck v1.14.0 (*)
│   └── wgpu v0.16.3
│       ├── arrayvec v0.7.4
│       ├── cfg-if v1.0.0
│       ├── log v0.4.20
│       ├── parking_lot v0.12.1 (*)
│       ├── profiling v1.0.13
│       ├── raw-window-handle v0.5.2
│       ├── smallvec v1.12.0
│       ├── static_assertions v1.1.0
│       ├── wgpu-core v0.16.1
│       │   ├── arrayvec v0.7.4
│       │   ├── bit-vec v0.6.3
│       │   ├── bitflags v2.4.2
│       │   ├── codespan-reporting v0.11.1 (*)
│       │   ├── log v0.4.20
│       │   ├── naga v0.12.3
│       │   │   ├── bit-set v0.5.3 (*)
│       │   │   ├── bitflags v1.3.2
│       │   │   ├── codespan-reporting v0.11.1 (*)
│       │   │   ├── hexf-parse v0.2.1
│       │   │   ├── indexmap v1.9.3 (*)
│       │   │   ├── log v0.4.20
│       │   │   ├── num-traits v0.2.17 (*)
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── spirv v0.2.0+1.5.4 (*)
│       │   │   ├── termcolor v1.4.1 (*)
│       │   │   ├── thiserror v1.0.56 (*)
│       │   │   └── unicode-xid v0.2.4
│       │   ├── parking_lot v0.12.1 (*)
│       │   ├── profiling v1.0.13
│       │   ├── raw-window-handle v0.5.2
│       │   ├── rustc-hash v1.1.0
│       │   ├── smallvec v1.12.0
│       │   ├── thiserror v1.0.56 (*)
│       │   ├── wgpu-hal v0.16.2
│       │   │   ├── arrayvec v0.7.4
│       │   │   ├── ash v0.37.3+1.3.251 (*)
│       │   │   ├── bit-set v0.5.3 (*)
│       │   │   ├── bitflags v2.4.2
│       │   │   ├── d3d12 v0.6.0
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   ├── libloading v0.7.4 (*)
│       │   │   │   └── winapi v0.3.9
│       │   │   ├── glow v0.12.3
│       │   │   ├── gpu-alloc v0.5.4
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   └── gpu-alloc-types v0.2.0
│       │   │   │       └── bitflags v1.3.2
│       │   │   ├── gpu-allocator v0.22.0 (*)
│       │   │   ├── gpu-descriptor v0.2.4 (*)
│       │   │   ├── hassle-rs v0.10.0 (*)
│       │   │   ├── khronos-egl v4.1.0 (*)
│       │   │   ├── libloading v0.8.1 (*)
│       │   │   ├── log v0.4.20
│       │   │   ├── naga v0.12.3 (*)
│       │   │   ├── parking_lot v0.12.1 (*)
│       │   │   ├── profiling v1.0.13
│       │   │   ├── range-alloc v0.1.3
│       │   │   ├── raw-window-handle v0.5.2
│       │   │   ├── renderdoc-sys v1.0.0
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── smallvec v1.12.0
│       │   │   ├── thiserror v1.0.56 (*)
│       │   │   ├── wgpu-types v0.16.1
│       │   │   │   └── bitflags v2.4.2
│       │   │   └── winapi v0.3.9
│       │   └── wgpu-types v0.16.1 (*)
│       ├── wgpu-hal v0.16.2 (*)
│       └── wgpu-types v0.16.1 (*)
├── rand v0.8.5
│   ├── rand_chacha v0.3.1
│   │   ├── ppv-lite86 v0.2.17
│   │   └── rand_core v0.6.4
│   │       └── getrandom v0.2.12
│   │           └── cfg-if v1.0.0
│   └── rand_core v0.6.4 (*)
├── rayon v1.8.1 (*)
├── winit v0.28.7 (*)
└── winit_input_helper v0.14.1
    └── winit v0.28.7 (*)

[njneeteson]

OK I see the problem.. wgpu v0.16 under pixels and wgpu v0.17 under egui-wgpu. But.. how do I fix this? I'm using the exact same versions of pixels and egui-wgpu as they are in the minimal-egui example, and that build doesnt have this problem. When I look at the tree there I get:

minimal-egui v0.1.0 (C:\Users\njnee\RustProjects\pixels\examples\minimal-egui)
├── egui v0.23.0
│   ├── ahash v0.8.6
│   │   ├── cfg-if v1.0.0
│   │   ├── once_cell v1.18.0
│   │   └── zerocopy v0.7.20
│   │   [build-dependencies]
│   │   └── version_check v0.9.4
│   ├── epaint v0.23.0
│   │   ├── ab_glyph v0.2.22
│   │   │   ├── ab_glyph_rasterizer v0.1.8
│   │   │   └── owned_ttf_parser v0.19.0
│   │   │       └── ttf-parser v0.19.2
│   │   ├── ahash v0.8.6 (*)
│   │   ├── bytemuck v1.14.0
│   │   │   └── bytemuck_derive v1.5.0 (proc-macro)
│   │   │       ├── proc-macro2 v1.0.69
│   │   │       │   └── unicode-ident v1.0.12
│   │   │       ├── quote v1.0.33
│   │   │       │   └── proc-macro2 v1.0.69 (*)
│   │   │       └── syn v2.0.38
│   │   │           ├── proc-macro2 v1.0.69 (*)
│   │   │           ├── quote v1.0.33 (*)
│   │   │           └── unicode-ident v1.0.12
│   │   ├── ecolor v0.23.0
│   │   │   └── bytemuck v1.14.0 (*)
│   │   ├── emath v0.23.0
│   │   │   └── bytemuck v1.14.0 (*)
│   │   ├── log v0.4.20
│   │   ├── nohash-hasher v0.2.0
│   │   └── parking_lot v0.12.1
│   │       ├── lock_api v0.4.11
│   │       │   └── scopeguard v1.2.0
│   │       │   [build-dependencies]
│   │       │   └── autocfg v1.1.0
│   │       └── parking_lot_core v0.9.9
│   │           ├── cfg-if v1.0.0
│   │           ├── smallvec v1.11.1
│   │           └── windows-targets v0.48.5
│   │               └── windows_x86_64_msvc v0.48.5
│   ├── log v0.4.20
│   └── nohash-hasher v0.2.0
├── egui-wgpu v0.23.0
│   ├── bytemuck v1.14.0 (*)
│   ├── epaint v0.23.0 (*)
│   ├── log v0.4.20
│   ├── thiserror v1.0.50
│   │   └── thiserror-impl v1.0.50 (proc-macro)
│   │       ├── proc-macro2 v1.0.69 (*)
│   │       ├── quote v1.0.33 (*)
│   │       └── syn v2.0.38 (*)
│   ├── type-map v0.5.0
│   │   └── rustc-hash v1.1.0
│   └── wgpu v0.17.1
│       ├── arrayvec v0.7.4
│       ├── cfg-if v1.0.0
│       ├── log v0.4.20
│       ├── parking_lot v0.12.1 (*)
│       ├── profiling v1.0.11
│       ├── raw-window-handle v0.5.2
│       ├── smallvec v1.11.1
│       ├── static_assertions v1.1.0
│       ├── wgpu-core v0.17.1
│       │   ├── arrayvec v0.7.4
│       │   ├── bit-vec v0.6.3
│       │   ├── bitflags v2.4.1
│       │   ├── codespan-reporting v0.11.1
│       │   │   ├── termcolor v1.3.0
│       │   │   │   └── winapi-util v0.1.6
│       │   │   │       └── winapi v0.3.9
│       │   │   └── unicode-width v0.1.11
│       │   ├── log v0.4.20
│       │   ├── naga v0.13.0
│       │   │   ├── bit-set v0.5.3
│       │   │   │   └── bit-vec v0.6.3
│       │   │   ├── bitflags v2.4.1
│       │   │   ├── codespan-reporting v0.11.1 (*)
│       │   │   ├── hexf-parse v0.2.1
│       │   │   ├── indexmap v1.9.3
│       │   │   │   └── hashbrown v0.12.3
│       │   │   │   [build-dependencies]
│       │   │   │   └── autocfg v1.1.0
│       │   │   ├── log v0.4.20
│       │   │   ├── num-traits v0.2.17
│       │   │   │   [build-dependencies]
│       │   │   │   └── autocfg v1.1.0
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── spirv v0.2.0+1.5.4
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   └── num-traits v0.2.17 (*)
│       │   │   ├── termcolor v1.3.0 (*)
│       │   │   ├── thiserror v1.0.50 (*)
│       │   │   └── unicode-xid v0.2.4
│       │   ├── parking_lot v0.12.1 (*)
│       │   ├── profiling v1.0.11
│       │   ├── raw-window-handle v0.5.2
│       │   ├── rustc-hash v1.1.0
│       │   ├── smallvec v1.11.1
│       │   ├── thiserror v1.0.50 (*)
│       │   ├── wgpu-hal v0.17.2
│       │   │   ├── arrayvec v0.7.4
│       │   │   ├── ash v0.37.3+1.3.251
│       │   │   │   └── libloading v0.7.4
│       │   │   │       └── winapi v0.3.9
│       │   │   ├── bit-set v0.5.3 (*)
│       │   │   ├── bitflags v2.4.1
│       │   │   ├── d3d12 v0.7.0
│       │   │   │   ├── bitflags v2.4.1
│       │   │   │   ├── libloading v0.8.1
│       │   │   │   │   └── windows-sys v0.48.0
│       │   │   │   │       └── windows-targets v0.48.5 (*)
│       │   │   │   └── winapi v0.3.9
│       │   │   ├── glow v0.12.3
│       │   │   ├── gpu-alloc v0.6.0
│       │   │   │   ├── bitflags v2.4.1
│       │   │   │   └── gpu-alloc-types v0.3.0
│       │   │   │       └── bitflags v2.4.1
│       │   │   ├── gpu-allocator v0.22.0
│       │   │   │   ├── backtrace v0.3.69
│       │   │   │   │   ├── cfg-if v1.0.0
│       │   │   │   │   └── rustc-demangle v0.1.23
│       │   │   │   │   [build-dependencies]
│       │   │   │   │   └── cc v1.0.83
│       │   │   │   ├── log v0.4.20
│       │   │   │   ├── thiserror v1.0.50 (*)
│       │   │   │   ├── winapi v0.3.9
│       │   │   │   └── windows v0.44.0
│       │   │   │       └── windows-targets v0.42.2
│       │   │   │           └── windows_x86_64_msvc v0.42.2
│       │   │   ├── gpu-descriptor v0.2.4
│       │   │   │   ├── bitflags v2.4.1
│       │   │   │   ├── gpu-descriptor-types v0.1.2
│       │   │   │   │   └── bitflags v2.4.1
│       │   │   │   └── hashbrown v0.14.2
│       │   │   │       ├── ahash v0.8.6 (*)
│       │   │   │       └── allocator-api2 v0.2.16
│       │   │   ├── hassle-rs v0.10.0
│       │   │   │   ├── bitflags v1.3.2
│       │   │   │   ├── com-rs v0.2.1
│       │   │   │   ├── libloading v0.7.4 (*)
│       │   │   │   ├── thiserror v1.0.50 (*)
│       │   │   │   ├── widestring v1.0.2
│       │   │   │   └── winapi v0.3.9
│       │   │   ├── khronos-egl v4.1.0
│       │   │   │   ├── libc v0.2.149
│       │   │   │   └── libloading v0.7.4 (*)
│       │   │   ├── libloading v0.8.1 (*)
│       │   │   ├── log v0.4.20
│       │   │   ├── naga v0.13.0 (*)
│       │   │   ├── parking_lot v0.12.1 (*)
│       │   │   ├── profiling v1.0.11
│       │   │   ├── range-alloc v0.1.3
│       │   │   ├── raw-window-handle v0.5.2
│       │   │   ├── renderdoc-sys v1.0.0
│       │   │   ├── rustc-hash v1.1.0
│       │   │   ├── smallvec v1.11.1
│       │   │   ├── thiserror v1.0.50 (*)
│       │   │   ├── wgpu-types v0.17.0
│       │   │   │   └── bitflags v2.4.1
│       │   │   └── winapi v0.3.9
│       │   └── wgpu-types v0.17.0 (*)
│       ├── wgpu-hal v0.17.2 (*)
│       └── wgpu-types v0.17.0 (*)
├── egui-winit v0.23.0
│   ├── egui v0.23.0 (*)
│   ├── log v0.4.20
│   ├── raw-window-handle v0.5.2
│   ├── web-time v0.2.3
│   ├── webbrowser v0.8.12
│   │   ├── log v0.4.20
│   │   └── url v2.4.1
│   │       ├── form_urlencoded v1.2.0
│   │       │   └── percent-encoding v2.3.0
│   │       ├── idna v0.4.0
│   │       │   ├── unicode-bidi v0.3.13
│   │       │   └── unicode-normalization v0.1.22
│   │       │       └── tinyvec v1.6.0
│   │       │           └── tinyvec_macros v0.1.1
│   │       └── percent-encoding v2.3.0
│   └── winit v0.28.7
│       ├── bitflags v1.3.2
│       ├── instant v0.1.12
│       │   └── cfg-if v1.0.0
│       ├── log v0.4.20
│       ├── once_cell v1.18.0
│       ├── raw-window-handle v0.5.2
│       └── windows-sys v0.45.0
│           └── windows-targets v0.42.2 (*)
│       [build-dependencies]
│       └── cfg_aliases v0.1.1
├── env_logger v0.10.0
│   ├── humantime v2.1.0
│   ├── is-terminal v0.4.9
│   │   └── windows-sys v0.48.0 (*)
│   ├── log v0.4.20
│   ├── regex v1.10.2
│   │   ├── aho-corasick v1.1.2
│   │   │   └── memchr v2.6.4
│   │   ├── memchr v2.6.4
│   │   ├── regex-automata v0.4.3
│   │   │   ├── aho-corasick v1.1.2 (*)
│   │   │   ├── memchr v2.6.4
│   │   │   └── regex-syntax v0.8.2
│   │   └── regex-syntax v0.8.2
│   └── termcolor v1.3.0 (*)
├── error-iter v0.4.1
├── log v0.4.20
├── pixels v0.13.0 (C:\Users\njnee\RustProjects\pixels)
│   ├── bytemuck v1.14.0 (*)
│   ├── pollster v0.3.0
│   ├── raw-window-handle v0.5.2
│   ├── thiserror v1.0.50 (*)
│   ├── ultraviolet v0.9.2
│   │   └── wide v0.7.13
│   │       ├── bytemuck v1.14.0 (*)
│   │       └── safe_arch v0.7.1
│   │           └── bytemuck v1.14.0 (*)
│   └── wgpu v0.17.1 (*)
├── winit v0.28.7 (*)
└── winit_input_helper v0.14.1
    └── winit v0.28.7 (*)

[dbalsom]

looks like the cargo package is lagging behind the repo. crates.io still says wgpu dependency is 0.16.

try adding pixels as a dependency via git instead of cargo.
ie, instead of
pixels = "0.13.0"
do
pixels = { git = "https://github.com/parasyte/pixels.git" }

then do another
cargo update

[njneeteson]

That fixed it. Amazing, thank you!

[dbalsom]

you're welcome! happy coding! you can also pin the dep to a specific commit, so dev work on the branch doesn't break your project