Okay, this seems promising

src/main.rs

@@ -1,3 +1,96 @@
-fn main() {
-    println!("Hello, world!");
+use iced::widget::{button, column, row, text, text_input};
+use iced::{Alignment, Color, Element, Event, Length, Task as Command, event};
+use iced_layershell::application;
+use iced_layershell::reexport::Anchor;
+use iced_layershell::settings::{LayerShellSettings, Settings, StartMode};
+use iced_layershell::to_layer_message;
+
+pub fn main() -> Result<(), iced_layershell::Error> {
+    let binded_output_name = std::env::args().nth(1);
+    let start_mode = match binded_output_name {
+        Some(output) => StartMode::TargetScreen(output),
+        None => StartMode::Active,
+    };
+
+    application(Counter::default, namespace, update, view)
+        .style(style)
+        .subscription(subscription)
+        .settings(Settings {
+            layer_settings: LayerShellSettings {
+                size: Some((400, 400)),
+                exclusive_zone: -1,
+                start_mode,
+                anchor: Anchor::empty(),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .run()
+}
+
+#[derive(Default)]
+struct Counter {
+    value: i32,
+    text: String,
+}
+
+#[to_layer_message]
+#[derive(Debug, Clone)]
+enum Message {
+    IncrementPressed,
+    DecrementPressed,
+    TextInput(String),
+    IcedEvent(Event),
+}
+
+fn namespace() -> String {
+    String::from("Counter - Iced")
+}
+
+fn subscription(_: &Counter) -> iced::Subscription<Message> {
+    event::listen().map(Message::IcedEvent)
+}
+
+fn update(counter: &mut Counter, message: Message) -> Command<Message> {
+    match message {
+        Message::IcedEvent(event) => {
+            println!("hello {event:?}");
+            Command::none()
+        }
+        Message::IncrementPressed => {
+            counter.value += 1;
+            Command::none()
+        }
+        Message::DecrementPressed => {
+            counter.value -= 1;
+            Command::none()
+        }
+        Message::TextInput(text) => {
+            counter.text = text;
+            Command::none()
+        }
+
+        _ => unreachable!(),
+    }
+}
+
+fn view(counter: &Counter) -> Element<'_, Message> {
+    column![
+        button("Increment").on_press(Message::IncrementPressed),
+        text(counter.value).size(50),
+        button("Decrement").on_press(Message::DecrementPressed)
+    ]
+    .align_x(Alignment::Center)
+    .padding(20)
+    .width(Length::Fill)
+    .height(Length::Fill)
+    .into()
+}
+
+fn style(_counter: &Counter, theme: &iced::Theme) -> iced::theme::Style {
+    use iced::theme::Style;
+    Style {
+        background_color: Color::WHITE,
+        text_color: theme.palette().text,
+    }
 }

src/my_main.rs

@@ -0,0 +1,50 @@
+use iced::{
+    Element,
+    widget::{Column, TextInput, text},
+};
+
+#[derive(Default)]
+struct State {
+    current_input: String,
+    old_messages: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    ContentChanged(String),
+    NewMessage,
+}
+
+impl State {
+    fn update(&mut self, message: Message) {
+        match message {
+            Message::ContentChanged(content) => {
+                self.current_input = content;
+            }
+
+            Message::NewMessage => {
+                self.old_messages
+                    .push(std::mem::take(&mut self.current_input));
+            }
+        }
+    }
+}
+
+impl State {
+    fn view(&self) -> Column<'_, Message> {
+        let input: TextInput<'_, Message> =
+            TextInput::new("Type something here...", &self.current_input)
+                .on_input(Message::ContentChanged)
+                .on_submit(Message::NewMessage);
+
+        Column::with_children(
+            std::iter::once(input.into())
+                .chain(self.old_messages.iter().map(|msg| text!("{msg}").into()))
+                .collect::<Vec<Element<_>>>(),
+        )
+    }
+}
+
+pub fn main() -> iced::Result {
+    iced::run(State::update, State::view)
+}