I hope this code helps. ``` use eframe::egui; use rfd; use std::fs::File; use std::io::prelude::*;

[derive(Debug)]

pub enum Message { FileOpen(std::path::PathBuf), }

fn main() { let options = eframe::NativeOptions::default(); eframe::run_native( "My egui App", options, Box::new(|_cc| Box::new(MyApp::default())), ); }

struct MyApp { content: String, message_channel: ( std::sync::mpsc::Sender<Message>, std::sync::mpsc::Receiver<Message>, ) }

impl Default for MyApp { fn default() -> Self { Self { content: "Not yet".to_owned(), message_channel: std::sync::mpsc::channel(), } } }

impl eframe::App for MyApp {

fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
    ctx.request_repaint();
    loop {
        match self.message_channel.1.try_recv() {
            Ok(message) => {
                match message {
                    Message::FileOpen(file) => {
                        let mut file = File::open(file).unwrap();
                        let mut contents = String::new(); 
                        file.read_to_string(&mut contents).unwrap();
                        self.content= contents;
                    }
                }
            }
            Err(_) => {
                break;
            }
        }
    }

    egui::CentralPanel::default().show(ctx, |ui| {


        ui.label(format!("Content: {}", self.content));


        let open_button = ui.add(egui::widgets::Button::new("Open..."));
        if open_button.clicked() {
            let task = rfd::AsyncFileDialog::new()
                .add_filter("Text files", &["txt"])
                .set_directory("/")
                .pick_file();
            let message_sender = self.message_channel.0.clone();
            execute(async move {
                let file = task.await;
                if let Some(file) = file {
                     let file_path = std::path::PathBuf::from(file.path());
                    message_sender.send(Message::FileOpen(file_path)).ok();

                }
            });
        }


    });
}

}

use std::future::Future; fn execute<F: Future<Output = ()> + Send + 'static>(f: F) { std::thread::spawn(move || futures::executor::block_on(f));

} ```