diff --git a/src/config.rs b/src/config.rs
index 5133621..d5897d0 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -38,7 +38,7 @@ pub struct Device {
 pub struct GUI {
    pub buttons: Buttons,
    pub release_prefix: String,
-   pub format: Option<String>,
+   pub format_keys: Option<String>,
    pub user: String,
    pub feedback: GUIFeedback,
 }
@@ -123,7 +123,7 @@ fn build_config_std() -> Config {
                   },
                   release_prefix: env::var("INPUT_GUI_RELEASE_PREFIX").unwrap_or(String::from("")),
                   user: env::var("INPUT_GUI_USER").unwrap_or(String::from("me")),
-                  format: match env::var("INPUT_GUI_FORMAT") {
+                  format_keys: match env::var("INPUT_GUI_FORMAT") {
                      Ok(x) => Some(x),
                      Err(_) => match env::var("INPUT_GUI_FORMAT_V01").unwrap_or(String::from("false")) == String::from("true") {
                         true => Some(String::from("{\"T\":{{ms}},\"U\":\"{{user}}\",\"Y\":\"{{pressed}}\",\"N\":\"{{released}}\"}")),
diff --git a/src/gui.rs b/src/gui.rs
index 155089b..6ee9add 100644
--- a/src/gui.rs
+++ b/src/gui.rs
@@ -6,7 +6,7 @@ use iced::subscription;
 use iced::{Alignment, Element, Application, Settings, Subscription, Theme, Command};
 use iced_futures::backend::native::async_std::time::every;
 use handlebars::Handlebars;
-use serde_json::json;
+use serde_json::{json, Value};
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::thread;
 use reqwest;
@@ -38,7 +38,8 @@ pub fn main(cfg: GUI, output_stream: Box<dyn OutputStream>) -> iced::Result {
 }
 
 struct Main {
-   c: std::sync::mpsc::Receiver<String>,
+   feedback_recv_c: std::sync::mpsc::Receiver<String>,
+   feedback_send_c: std::sync::mpsc::Sender<String>,
    ntfy_from_client: String,
    ntfy_from_server: String,
    configuring: Option<Message>,
@@ -114,6 +115,16 @@ impl Main {
    }
 
    fn send_say(&mut self, text: String) {
+      if text.len() == 0 {
+         return;
+      }
+      if text.len() > 1000 {
+         return;
+      }
+      match self.feedback_send_c.send(text.clone()) {
+         Ok(_) => {},
+         Err(err) => eprintln!("main.send_say() failed to enqueue {}: {}", text, err),
+      };
    }
 
    fn exchange(&mut self) {
@@ -123,7 +134,7 @@ impl Main {
 
    fn exchange_recv(&mut self) {
       loop {
-         match self.c.try_recv() {
+         match self.feedback_recv_c.try_recv() {
             Ok(msg) => {
                self.ntfy_from_server = msg
             },
@@ -161,21 +172,24 @@ impl Main {
          };
       }
       if t.len() + s.len() > 0 {
-         self.flags.output_stream.put(self.sprintf(s, t));
+         self.flags.output_stream.put(self.sprintf_pressed_released(s, t));
       }
       self.keys_up.clear();
    }
 
-   fn sprintf(&self, pressed: Vec<char>, released: Vec<char>) -> Vec<char> {
-      match self.flags.cfg.format.clone() {
+   fn sprintf(&self, format: &String, content: &Value) -> Vec<char> {
+      return Handlebars::new().render_template(format, content).unwrap().chars().collect();
+   }
+
+   fn sprintf_pressed_released(&self, pressed: Vec<char>, released: Vec<char>) -> Vec<char> {
+      match self.flags.cfg.format_keys.clone() {
          Some(x) => {
-            let reg = Handlebars::new();
-            return reg.render_template(&x, &json!({
+            return self.sprintf(&x, &json!({
                "pressed": pressed.iter().collect::<String>(),
                "released": released.iter().collect::<String>(),
                "ms": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis(),
                "user": self.flags.cfg.user,
-            })).unwrap().chars().collect();
+            }));
          },
          None => {
             let mut combo = vec![];
@@ -194,16 +208,19 @@ impl Application for Main {
    type Executor = executor::Default;
 
    fn new(flags: Self::Flags) -> (Self, Command<Message>) {
-      let (sender, receiver) = std::sync::mpsc::channel();
+      let (sender1, receiver1) = std::sync::mpsc::channel();
+      let (sender2, receiver2) = std::sync::mpsc::channel();
       let feedback_cfg = flags.cfg.feedback.clone();
       thread::spawn(move || {
          Feedback{
-            c: sender,
+            send_c: sender1,
+            recv_c: receiver2,
             cfg: feedback_cfg,
          }.listen()
       });
       return (Self {
-         c: receiver,
+         feedback_send_c: sender2,
+         feedback_recv_c: receiver1,
          ntfy_from_client: String::from(" "),
          ntfy_from_server: String::from(" "),
          configuring: None,
@@ -375,7 +392,8 @@ impl Application for Main {
 }
 
 struct Feedback {
-   c: std::sync::mpsc::Sender<String>,
+   send_c: std::sync::mpsc::Sender<String>,
+   recv_c: std::sync::mpsc::Receiver<String>,
    cfg: GUIFeedback,
 }
 
@@ -383,16 +401,24 @@ impl Feedback {
    fn listen(&mut self) {
       loop {
          std::thread::sleep(std::time::Duration::from_secs(2));
-         match self.read() {
+         match self.read_from_server() {
             Some(msg) if msg.len() > 0 => {
-               self.write(msg.clone());
+               self.write_from_server(msg.clone());
             },
             _ => {},
          };
+         /*
+         match self.read_from_client() {
+            Some(msg) if msg.len() > 0 => {
+               self.write_from_client(msg.clone());
+            },
+            _ => {},
+         };
+         */
       }
    }
 
-   fn read(&mut self) -> Option<String> {
+   fn read_from_server(&mut self) -> Option<String> {
       return match &self.cfg.url {
          Some(url) => {
             match reqwest::blocking::get(url) {
@@ -410,11 +436,26 @@ impl Feedback {
       };
    }
 
-   fn write(&mut self, msg: String) {
-      match self.c.send(msg.clone()) {
+   fn write_from_server(&mut self, msg: String) {
+      match self.send_c.send(msg.clone()) {
          Ok(_) => {},
          Err(err) => eprintln!("feedback.listen() failed to display {}: {}", msg, err),
       };
    }
+
+/*
+   fn read_from_client(&mut self) -> Option<String> {
+      let last: Option<String> = None;
+      loop {
+         match self.recv_c.try_recv() {
+            Ok(msg) => {
+               last = msg;
+            },
+            _ => break,
+         };
+      }
+      return last;
+   }
+   */
 }