diff --git a/main.rs b/main.rs
new file mode 100644
index 0000000..797d5e9
--- /dev/null
+++ b/main.rs
@@ -0,0 +1,123 @@
+use std::fmt::Debug;
+use std::str::from_utf8;
+use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+
+use actix_web::{App, get, HttpServer, web::Data};
+use rumqttc::{Client, Event, Incoming, MqttOptions, QoS};
+use serde::{Deserialize, Serialize};
+
+use todolist::services;
+
+mod todolist;
+
+struct AppState {
+    todolist_entries: Mutex<Vec<TodolistEntry>>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct TodolistEntry {
+    id: i32,
+    date: i64,
+    title: String,
+}
+
+#[get("/")]
+async fn index() -> String {
+    "This is a health check".to_string()
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    let state = AppState {
+        todolist_entries: Mutex::new(Vec::new()),
+    };
+
+    let app_data = Data::new(state);
+
+    let state_arc = app_data.clone().into_inner();
+    let state_arc_cloned = state_arc.clone();
+
+    thread::spawn(move || {
+        loop {
+            {
+                let todolist = match state_arc_cloned.todolist_entries.lock() {
+                    Ok(guard) => guard,
+                    Err(poisoned) => poisoned.into_inner(),
+                };
+                println!("Data: {:?}", todolist.to_vec());
+            }
+            thread::sleep(Duration::from_millis(1000));
+        }
+    });
+
+    let mut mqttoptions = MqttOptions::new("rumqtt-sync", "test.mosquitto.org", 1883);
+    mqttoptions.set_keep_alive(Duration::from_secs(5));
+
+    let (mut client, mut connection) = Client::new(mqttoptions, 10);
+
+    let result = client.subscribe("hello/rumqtt", QoS::AtLeastOnce);
+    match result {
+        Ok(val) => {
+            println!("Subscribed. {:?}", val)
+        }
+        Err(e) => {
+            println!("Error subscribing. {:?}", e)
+        }
+    }
+
+    // let result = client.subscribe("zigbee2mqtt/#", QoS::AtLeastOnce);
+    // match result {
+    //     Ok(val) => {
+    //         println!("Subscribed. {:?}", val)
+    //     }
+    //     Err(e) => {
+    //         println!("Error subscribing. {:?}", e)
+    //     }
+    // }
+
+    thread::spawn(move || {
+        for i in 0..10 {
+            client.publish("hello/rumqtt", QoS::AtLeastOnce, false, vec![i; i as usize]).unwrap();
+            thread::sleep(Duration::from_millis(100));
+        }
+    });
+
+    thread::spawn(move || {
+        for (_i, notification) in connection.iter().enumerate() {
+            match notification {
+                Ok(event) => {
+                    match event {
+                        Event::Incoming(Incoming::Publish(publish)) => {
+                            let payload = from_utf8(&publish.payload).unwrap_or("");
+                            println!("Topic: {:?}, Qos: {:?}, Retain: {}, Pkid: {:?}, Payload: {:?}",
+                                     publish.topic,
+                                     publish.qos,
+                                     publish.retain,
+                                     publish.pkid,
+                                     payload,
+                            );
+                        }
+                        Event::Incoming(e) => {
+                            println!("{:?}", e)
+                        }
+                        _ => {}
+                    }
+                }
+                _ => {}
+            }
+        }
+        println!("ENDE");
+    });
+
+    HttpServer::new(move || {
+        App::new()
+            .app_data(app_data.clone())
+            .service(index)
+            .configure(services::config)
+    })
+        .bind(("127.0.0.1", 8080))?
+        .run()
+        .await
+}