Cargo.lock

@@ -273,6 +273,29 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alacritty_terminal"
+version = "0.24.1-dev"
+source = "git+https://github.com/alacritty/alacritty?rev=cacdb5bb3b72bad2c729227537979d95af75978f#cacdb5bb3b72bad2c729227537979d95af75978f"
+dependencies = [
+ "base64 0.22.1",
+ "bitflags 2.5.0",
+ "home",
+ "libc",
+ "log",
+ "miow",
+ "parking_lot 0.12.2",
+ "piper",
+ "polling",
+ "regex-automata",
+ "rustix-openpty",
+ "serde",
+ "signal-hook",
+ "unicode-width",
+ "vte",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "alloc-no-stdlib"
 version = "2.0.4"
@@ -1240,6 +1263,12 @@ dependencies = [
  "syn 2.0.90",
 ]
 
+[[package]]
+name = "cursor-icon"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"
+
 [[package]]
 name = "darling"
 version = "0.20.8"
@@ -1674,6 +1703,7 @@ checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
 name = "fastwave"
 version = "0.1.0"
 dependencies = [
+ "alacritty_terminal",
  "futures",
  "once_cell",
  "reqwest",
@@ -1793,6 +1823,7 @@ version = "0.1.0"
 dependencies = [
  "gloo-file",
  "shared",
+ "unicode-segmentation",
  "wasm-bindgen-test",
  "web-sys",
  "wellen",
@@ -2409,12 +2440,27 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "home"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "hsluv"
 version = "0.1.0"
@@ -2718,7 +2764,7 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.9",
  "libc",
  "windows-sys 0.52.0",
 ]
@@ -3172,6 +3218,15 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "miow"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "359f76430b20a79f9e20e115b3428614e654f04fab314482fc0fda0ebd3c6044"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "moon"
 version = "0.1.0"
@@ -3966,6 +4021,17 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "piper"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.30"
@@ -3999,6 +4065,21 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "polling"
+version = "3.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi 0.4.0",
+ "pin-project-lite",
+ "rustix",
+ "tracing",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "postcard"
 version = "1.0.8"
@@ -4496,6 +4577,17 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rustix-openpty"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a25c3aad9fc1424eb82c88087789a7d938e1829724f3e4043163baf0d13cfc12"
+dependencies = [
+ "errno",
+ "libc",
+ "rustix",
+]
+
 [[package]]
 name = "rustls"
 version = "0.21.11"
@@ -4906,6 +4998,16 @@ dependencies = [
  "dirs 4.0.0",
 ]
 
+[[package]]
+name = "signal-hook"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.2"
@@ -6079,6 +6181,12 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "uuid"
 version = "1.8.0"
@@ -6127,6 +6235,30 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "vte"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40eb22ae96f050e0c0d6f7ce43feeae26c348fc4dea56928ca81537cfaa6188b"
+dependencies = [
+ "bitflags 2.5.0",
+ "cursor-icon",
+ "log",
+ "serde",
+ "utf8parse",
+ "vte_generate_state_changes",
+]
+
+[[package]]
+name = "vte_generate_state_changes"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e369bee1b05d510a7b4ed645f5faa90619e05437111783ea5848f28d97d3c2e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"

frontend/Cargo.toml

@@ -14,6 +14,7 @@ wasm-bindgen-test = "0.3.19"
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(FASTWAVE_PLATFORM)'] }
 
 [dependencies]
+unicode-segmentation = "1.10"
 zoon.workspace = true
 wellen.workspace = true
 shared = { path = "../shared", features = ["frontend"] }

frontend/src/header_panel.rs

@@ -1,6 +1,7 @@
 use crate::{platform, theme::*, Filename, Layout, Mode};
 use std::sync::Arc;
 use zoon::*;
+use crate::term::TERM_OPEN;
 
 pub struct HeaderPanel {
     hierarchy: Mutable<Option<Arc<wellen::Hierarchy>>>,
@@ -37,6 +38,7 @@ impl HeaderPanel {
                     .item(self.load_button())
                     .item(self.layout_switcher())
                     .item(self.mode_switcher())
+                    .item(self.open_terminal())
                     .item(self.open_konata_file()),
             )
     }
@@ -212,4 +214,26 @@ impl HeaderPanel {
             .on_hovered_change(move |is_hovered| hovered.set_neq(is_hovered))
             .on_press(move || Task::start(platform::open_konata_file()))
     }
+
+    fn open_terminal(&self) -> impl Element {
+        let (hovered, hovered_signal) = Mutable::new_and_signal(false);
+        Button::new()
+            .s(Padding::new().x(20).y(10))
+            .s(Background::new().color_signal(
+                hovered_signal.map_bool(|| COLOR_MEDIUM_SLATE_BLUE, || COLOR_SLATE_BLUE),
+            ))
+            .s(Align::new().left())
+            .s(RoundedCorners::all(15))
+            .label(
+                El::new()
+                    .s(Font::new().no_wrap())
+                    .child("Open Terminal"),
+            )
+            .on_hovered_change(move |is_hovered| hovered.set_neq(is_hovered))
+            .on_press(move || {
+                let term_open = TERM_OPEN.get();
+                TERM_OPEN.set(!term_open);
+
+            })
+    }
 }

frontend/src/main.rs

@@ -1,4 +1,5 @@
 use shared::DiagramConnectorMessage;
+use term::TERM_OPEN;
 use std::{mem, sync::Arc};
 use zoon::*;
 
@@ -23,6 +24,9 @@ use command_panel::CommandPanel;
 pub mod theme;
 use theme::*;
 
+pub mod term;
+use shared::term::{TerminalDownMsg, TerminalScreen};
+
 #[derive(Clone, Copy, Default)]
 enum Layout {
     Tree,
@@ -98,8 +102,10 @@ fn main() {
                     .unwrap_throw()
                     .set_component_text(&component_id, &text),
             }
-        })
-        .await
+        }).await;
+        platform::listen_term_update(|down_msg| {
+            term::TERMINAL_STATE.set(down_msg);
+        }).await;
     });
 }
 
@@ -181,4 +187,20 @@ fn root() -> impl Element {
             }
         })))
         .item(CommandPanel::new())
+        .item_signal(
+            TERM_OPEN.signal_cloned().map(
+                |term_open| {
+                    match term_open {
+                        true =>
+                            El::new()
+                                .s(Height::fill().max(400).min(400))
+                                .s(Padding::all(5))
+                                .child(term::root()),
+                        false =>
+                            El::new()
+                                .child("")
+                    }
+                }
+            )
+        )
 }

frontend/src/platform.rs

@@ -29,6 +29,8 @@ type DiagramConnectorPath = String;
 type DiagramConnectorName = String;
 type ComponentId = String;
 
+use shared::term::{TerminalDownMsg, TerminalScreen};
+
 pub async fn show_window() {
     platform::show_window().await
 }
@@ -72,6 +74,10 @@ pub async fn unload_signal(signal_ref: wellen::SignalRef) {
     platform::unload_signal(signal_ref).await
 }
 
+pub async fn send_char(c : String) {
+    platform::send_char(c).await
+}
+
 pub async fn add_decoders(decoder_paths: Vec<DecoderPath>) -> AddedDecodersCount {
     let count = platform::add_decoders(decoder_paths).await;
     if count > 0 {
@@ -112,6 +118,12 @@ pub async fn listen_diagram_connectors_messages(
     platform::listen_diagram_connectors_messages(on_message).await;
 }
 
+pub async fn listen_term_update(
+    on_message: impl FnMut(TerminalDownMsg) + 'static,
+) {
+    platform::listen_term_update(on_message).await;
+}
+
 pub async fn notify_diagram_connector_text_change(
     diagram_connector: DiagramConnectorName,
     component_id: ComponentId,

frontend/src/platform/tauri.rs

@@ -1,4 +1,5 @@
 use shared::DiagramConnectorMessage;
+use shared::term::{TerminalDownMsg, TerminalScreen};
 use zoon::*;
 
 pub(super) async fn show_window() {
@@ -57,6 +58,12 @@ pub(super) async fn unload_signal(signal_ref: wellen::SignalRef) {
         .unwrap_throw()
 }
 
+pub(super) async fn send_char(c : String) {
+    tauri_glue::send_char(c)
+        .await
+        .unwrap_throw()
+}
+
 pub(super) async fn add_decoders(
     decoder_paths: Vec<super::DecoderPath>,
 ) -> super::AddedDecodersCount {
@@ -97,6 +104,14 @@ pub(super) async fn listen_diagram_connectors_messages(
     tauri_glue::listen_diagram_connectors_messages(Closure::new(on_message).into_js_value()).await
 }
 
+pub(super) async fn listen_term_update(
+    mut on_message: impl FnMut(TerminalDownMsg) + 'static,
+) {
+    let on_message =
+        move |message: JsValue| on_message(serde_wasm_bindgen::from_value(message).unwrap_throw());
+    tauri_glue::listen_term_update(Closure::new(on_message).into_js_value()).await
+}
+
 pub(super) async fn notify_diagram_connector_text_change(
     diagram_connector: super::DiagramConnectorName,
     component_id: super::ComponentId,
@@ -142,6 +157,9 @@ mod tauri_glue {
         #[wasm_bindgen(catch)]
         pub async fn unload_signal(signal_ref_index: usize) -> Result<(), JsValue>;
 
+        #[wasm_bindgen(catch)]
+        pub async fn send_char(c : String) -> Result<(), JsValue>;
+
         #[wasm_bindgen(catch)]
         pub async fn add_decoders(
             decoder_paths: Vec<super::super::DecoderPath>,
@@ -160,6 +178,8 @@ mod tauri_glue {
 
         pub async fn listen_diagram_connectors_messages(on_event: JsValue);
 
+        pub async fn listen_term_update(on_event: JsValue);
+
         #[wasm_bindgen(catch)]
         pub async fn notify_diagram_connector_text_change(
             diagram_connector: super::super::DiagramConnectorName,

frontend/src/term.rs

@@ -0,0 +1,142 @@
+use std::ops::Index;
+
+use chrono::format;
+use zoon::*;
+use zoon::{println, eprintln, *};
+use shared::term::{TerminalDownMsg, TerminalScreen, TerminalUpMsg};
+use unicode_segmentation::UnicodeSegmentation;
+
+// use tokio::time::timeout;
+pub static TERM_OPEN: Lazy<Mutable<bool>> = Lazy::new(|| {false.into()});
+
+pub const TERMINAL_COLOR: Oklch = color!("oklch(20% 0.125 262.26)");
+
+pub static  TERMINAL_STATE: Lazy<Mutable<TerminalDownMsg>> =
+    Lazy::new(|| {
+        Mutable::new(TerminalDownMsg::TermNotStarted)
+    });
+
+pub fn root() -> impl Element {
+    let terminal =
+        El::new()
+            .s(Width::fill())
+            .s(Height::fill())
+            .s(Background::new().color(TERMINAL_COLOR))
+            .s(RoundedCorners::all(7))
+            .s(Font::new().family([
+                FontFamily::new("Lucida Console"),
+                FontFamily::new("Courier"),
+                FontFamily::new("monospace")
+                ]))
+            .update_raw_el(|raw_el| {
+                raw_el.global_event_handler(|event: events::KeyDown| {
+                    send_char(
+                        (&event).key().as_str(),
+                        (&event).ctrl_key(),
+                    );
+                })
+            })
+            .child_signal(TERMINAL_STATE.signal_cloned().map(
+                |down_msg| {
+                    match down_msg {
+                        TerminalDownMsg::FullTermUpdate(term) => {
+                            make_grid_with_newlines(&term)
+                        },
+                        TerminalDownMsg::TermNotStarted => {
+                            "Term not yet started!".to_string()
+                        },
+                        TerminalDownMsg::BackendTermStartFailure(msg) => {
+                            format!("Error: BackendTermStartFailure: {}", msg)
+                        }
+                    }
+                }
+                )
+            )
+            ;
+    let root = Column::new()
+        .s(Width::fill())
+        .s(Height::fill())
+        .s(Align::new().top())
+        .item(terminal);
+    root
+}
+
+fn send_char(
+    s           : &str,
+    has_control : bool,
+    ) {
+    match process_str(s, has_control) {
+        Some(c) => {
+            let send_c = c.clone();
+            Task::start(async move {
+                crate::platform::send_char(send_c.to_string()).await;
+            });
+        }
+        None => {}
+    }
+
+}
+
+
+fn make_grid_with_newlines(term: &TerminalScreen) -> String {
+    let mut formatted = String::with_capacity(term.content.len() + (term.content.len() / term.cols as usize));
+
+    term.content.chars().enumerate().for_each(|(i, c)| {
+        formatted.push(c);
+        if (i + 1) as u16 % term.cols == 0 {
+            formatted.push('\n');
+        }
+    });
+
+    formatted
+}
+
+
+fn process_str(s: &str, has_ctrl: bool) -> Option<char> {
+    match s {
+        "Enter"         => {return Some('\n');}
+        "Escape"        => {return Some('\x1B');}
+        "Backspace"     => {return Some('\x08');}
+        "ArrowUp"       => {return Some('\x10');}
+        "ArrowDown"     => {return Some('\x0E');}
+        "ArrowLeft"     => {return Some('\x02');}
+        "ArrowRight"    => {return Some('\x06');}
+        "Control"       => {return None;}
+        "Shift"         => {return None;}
+        "Meta"          => {return None;}
+        "Alt"           => {return None;}
+        _ => {}
+    }
+
+    let mut graphemes = s.graphemes(true);
+    let first = graphemes.next();
+
+    if let Some(g) = first {
+        if g.len() == 1 {
+            if let Some(c) = g.chars().next() {
+                let c = process_for_ctrl_char(c, has_ctrl);
+                return Some(c);
+            }
+        }
+    }
+
+    None
+}
+
+// Helper function to process control characters
+
+fn is_lowercase_alpha(c: char) -> bool {
+    char_is_between_inclusive(c, 'a', 'z')
+}
+
+fn process_for_ctrl_char(c: char, has_ctrl: bool) -> char {
+    if has_ctrl {
+        (c as u8 & 0x1F) as char
+    } else {
+        c
+    }
+}
+
+fn char_is_between_inclusive(c : char, lo_char : char, hi_char : char) -> bool {
+    c >= lo_char && c <= hi_char
+}

frontend/typescript/tauri_glue/tauri_glue.ts

@@ -38,20 +38,20 @@ export async function get_hierarchy(): Promise<WellenHierarchy> {
 }
 
 export async function load_signal_and_get_timeline(
-    signal_ref_index: number, 
+    signal_ref_index: number,
     timeline_zoom: number,
     timeline_viewport_width: number,
-    timeline_viewport_x: number, 
+    timeline_viewport_x: number,
     block_height: number,
     var_format: VarFormat,
 ): Promise<Timeline> {
-    return await invoke("load_signal_and_get_timeline", { 
-        signal_ref_index, 
-        timeline_zoom, 
+    return await invoke("load_signal_and_get_timeline", {
+        signal_ref_index,
+        timeline_zoom,
         timeline_viewport_width,
         timeline_viewport_x,
-        block_height, 
-        var_format 
+        block_height,
+        var_format
     });
 }
 
@@ -59,6 +59,10 @@ export async function unload_signal(signal_ref_index: number): Promise<void> {
     return await invoke("unload_signal", { signal_ref_index });
 }
 
+export async function send_char(c : string): Promise<void> {
+    return await invoke("send_char", { c });
+}
+
 export async function add_decoders(decoder_paths: Array<DecoderPath>): Promise<AddedDecodersCount> {
     return await invoke("add_decoders", { decoder_paths });
 }
@@ -79,6 +83,10 @@ export async function listen_diagram_connectors_messages(on_message: (message: a
     return await listen("diagram_connector_message", (message) => on_message(message.payload));
 }
 
+export async function listen_term_update(on_message: (message: any) => void) {
+    return await listen("term_content", (message) => on_message(message.payload));
+}
+
 export async function notify_diagram_connector_text_change(diagram_connector: DiagramConnectorName, component_id: ComponentId, text: string): Promise<void> {
     return await invoke("notify_diagram_connector_text_change", { diagram_connector, component_id, text });
 }

shared/src/lib.rs

@@ -7,6 +7,7 @@ mod signal_to_timeline;
 pub use signal_to_timeline::signal_to_timeline;
 
 pub mod wellen_helpers;
+pub mod term;
 
 #[derive(Serialize, Deserialize, Debug, Default)]
 #[serde(crate = "serde")]

shared/src/term.rs

@@ -0,0 +1,25 @@
+use moonlight::*;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(crate = "serde")]
+pub enum TerminalUpMsg {
+    RequestFullTermState,
+    RequestIncrementalTermStateUpdate,
+    SendCharacter(char),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(crate = "serde")]
+pub enum TerminalDownMsg {
+    FullTermUpdate(TerminalScreen),
+    BackendTermStartFailure(String),
+    TermNotStarted
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+#[serde(crate = "serde")]
+pub struct TerminalScreen {
+    pub cols    : u16,
+    pub rows    : u16,
+    pub content : String,
+}

src-tauri/Cargo.toml

@@ -17,6 +17,7 @@ tauri-build = { version = "2.0.3", features = [] }
 
 [dependencies]
 wellen.workspace = true
+alacritty_terminal = { git = "https://github.com/alacritty/alacritty", rev = "cacdb5bb3b72bad2c729227537979d95af75978f" }
 shared = { path = "../shared", features = ["backend"] }
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }

src-tauri/f.txt

@@ -0,0 +1,2 @@
+Hello, I'm typing a file in vim!!
+

src-tauri/src/aterm.rs

@@ -0,0 +1,116 @@
+use std::result;
+use std::sync::{mpsc, Arc};
+
+use alacritty_terminal::event::{Event, EventListener};
+use alacritty_terminal::event_loop::{EventLoop, Notifier};
+use alacritty_terminal::sync::FairMutex;
+use alacritty_terminal::term::{self, Term};
+use alacritty_terminal::term::cell::Cell;
+use alacritty_terminal::{tty, Grid};
+use tauri::Emitter;
+use shared::term::{TerminalDownMsg, TerminalScreen};
+
+use crate::terminal_size;
+
+#[derive(Clone)]
+pub struct EventProxy(mpsc::Sender<Event>);
+impl EventListener for EventProxy {
+    fn send_event(&self, event: Event) {
+        let _ = self.0.send(event.clone());
+    }
+}
+
+pub struct ATerm {
+    pub term: Arc<FairMutex<Term<EventProxy>>>,
+
+    pub rows : u16,
+    pub cols : u16,
+
+    /// Use tx to write things to terminal instance from outside world
+    pub tx: Notifier,
+
+    /// Use rx to read things from terminal instance.
+    /// Rx only has data when terminal state has changed,
+    /// otherwise, `std::sync::mpsc::recv` will block and sleep
+    /// until there is data.
+    pub rx: mpsc::Receiver<(u64, Event)>,
+}
+
+impl ATerm {
+    pub fn new() -> result::Result<ATerm, std::io::Error> {
+        let (rows, cols) = (21, 85);
+        let id = 1;
+        let pty_config = tty::Options {
+            shell: Some(tty::Shell::new("/bin/bash".to_string(), vec![])),
+            ..tty::Options::default()
+        };
+        let config = term::Config::default();
+        let terminal_size = terminal_size::TerminalSize::new(rows, cols);
+        let pty = tty::new(&pty_config, terminal_size.into(), id)?;
+        let (event_sender, event_receiver) = mpsc::channel();
+        let event_proxy = EventProxy(event_sender);
+        let term = Term::new::<terminal_size::TerminalSize>(
+            config,
+            &terminal_size.into(),
+            event_proxy.clone(),
+        );
+        let term = Arc::new(FairMutex::new(term));
+        let pty_event_loop = EventLoop::new(term.clone(), event_proxy, pty, false, false)?;
+        let notifier = Notifier(pty_event_loop.channel());
+        let (pty_proxy_sender, pty_proxy_receiver) = std::sync::mpsc::channel();
+        // Start pty event loop
+        pty_event_loop.spawn();
+        std::thread::Builder::new()
+            .name(format!("pty_event_subscription_{}", id))
+            .spawn(move || loop {
+                if let Ok(event) = event_receiver.recv() {
+                    if let Event::Exit = event {
+                        break;
+                    }
+                    else {
+                        if let Some(app_handle) = crate::APP_HANDLE.read().unwrap().clone() {
+                            let term = crate::TERM.lock().unwrap();
+                            let content = terminal_instance_to_string(&term);
+                            let payload = TerminalScreen {
+                                cols: term.cols,
+                                rows: term.rows,
+                                content: content
+                            };
+                            let payload = TerminalDownMsg::FullTermUpdate(payload);
+                            let payload = serde_json::json!(payload);
+                            app_handle.emit("term_content", payload).unwrap();
+                        }
+                    }
+                }
+            })?;
+        Ok(ATerm {
+            term,
+            rows,
+            cols,
+            tx: notifier,
+            rx: pty_proxy_receiver,
+        })
+    }
+}
+
+pub fn terminal_instance_to_string(terminal_instance: &ATerm) -> String {
+    let (rows, cols) = (terminal_instance.rows, terminal_instance.cols);
+    let term = terminal_instance.term.lock();
+    let grid = term.grid().clone();
+
+    return term_grid_to_string(&grid, rows, cols);
+}
+
+fn term_grid_to_string(grid: &Grid<Cell>, rows: u16, cols: u16) -> String {
+    let mut term_content = String::with_capacity((rows*cols) as usize);
+
+    // Populate string from grid
+    for indexed in grid.display_iter() {
+        let x = indexed.point.column.0 as usize;
+        let y = indexed.point.line.0 as usize;
+        if y < rows as usize && x < cols as usize {
+            term_content.push(indexed.c);
+        }
+    }
+    return term_content;
+}

src-tauri/src/lib.rs

@@ -8,6 +8,7 @@ use tauri_plugin_dialog::DialogExt;
 use tokio::time::sleep;
 use wasmtime::AsContextMut;
 use wellen::simple::Waveform;
+use tauri::Emitter;
 
 type Filename = String;
 type JavascriptCode = String;
@@ -21,15 +22,25 @@ type RemovedDiagramConnectorsCount = usize;
 type DiagramConnectorPath = String;
 type DiagramConnectorName = String;
 type ComponentId = String;
+use alacritty_terminal::event::Notify;
+use shared::term::{TerminalDownMsg, TerminalScreen};
 
 mod component_manager;
+mod aterm;
+mod terminal_size;
+use std::sync::Mutex;
 
 pub static APP_HANDLE: Lazy<Arc<StdRwLock<Option<AppHandle>>>> = Lazy::new(<_>::default);
 pub static WAVEFORM: Lazy<StdRwLock<Arc<RwLock<Option<Waveform>>>>> = Lazy::new(<_>::default);
 
+static TERM: Lazy<Mutex<aterm::ATerm>> = Lazy::new(|| {
+    Mutex::new(aterm::ATerm::new().expect("Failed to initialize ATerm"))
+});
+
 #[derive(Default)]
 struct Store {
     waveform: Arc<RwLock<Option<Waveform>>>,
+    val     : Arc<RwLock<bool>>,
 }
 
 #[tauri::command(rename_all = "snake_case")]
@@ -144,6 +155,17 @@ async fn unload_signal(signal_ref_index: usize, store: tauri::State<'_, Store>)
     Ok(())
 }
 
+#[tauri::command(rename_all = "snake_case")]
+async fn send_char(c : String) -> Result<(), ()> {
+    if c.len() == 1 {
+        let term = TERM.lock().unwrap();
+        term.tx.notify(c.into_bytes());
+        Ok(())
+    } else {
+        Err(())
+    }
+}
+
 #[tauri::command(rename_all = "snake_case")]
 async fn add_decoders(decoder_paths: Vec<DecoderPath>) -> Result<AddedDecodersCount, ()> {
     Ok(component_manager::decoders::add_decoders(decoder_paths).await)
@@ -279,6 +301,7 @@ pub fn run() {
             get_hierarchy,
             load_signal_and_get_timeline,
             unload_signal,
+            send_char,
             add_decoders,
             remove_all_decoders,
             add_diagram_connectors,
@@ -288,6 +311,27 @@ pub fn run() {
         ])
         .setup(|app| {
             *APP_HANDLE.write().unwrap() = Some(app.handle().to_owned());
+            println!("Setting up yay!");
+
+            std::thread::spawn(move || {
+                // Simulate emitting a message after a delay
+                std::thread::sleep(std::time::Duration::from_secs(1));
+
+                //tart term and send initial update to backend
+                if let Some(app_handle) = crate::APP_HANDLE.read().unwrap().clone() {
+                    let term = crate::TERM.lock().unwrap();
+                    let content = crate::aterm::terminal_instance_to_string(&term);
+                    let payload = TerminalScreen {
+                        cols: term.cols,
+                        rows: term.rows,
+                        content: content
+                    };
+                    let payload = TerminalDownMsg::FullTermUpdate(payload);
+                    let payload = serde_json::json!(payload);
+                    app_handle.emit("term_content", payload).unwrap();
+                }
+            });
+
             Ok(())
         })
         .run(tauri::generate_context!())

src-tauri/src/main.rs

@@ -1,6 +1,8 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+mod terminal_size;
+
 fn main() {
     app_lib::run();
 }

src-tauri/src/terminal_size.rs

@@ -0,0 +1,55 @@
+use alacritty_terminal::event::{WindowSize};
+use alacritty_terminal::grid::{Dimensions};
+use alacritty_terminal::index::{Column, Line};
+
+#[derive(Clone, Copy, Debug)]
+pub struct TerminalSize {
+    pub cell_width: u16,
+    pub cell_height: u16,
+    pub num_cols: u16,
+    pub num_lines: u16,
+}
+
+impl TerminalSize {
+    pub fn new(rows : u16, cols : u16) -> Self {
+        Self {
+            cell_width: 1,
+            cell_height: 1,
+            num_cols: cols,
+            num_lines: rows,
+        }
+    }
+}
+
+impl Dimensions for TerminalSize {
+    fn total_lines(&self) -> usize {
+        self.screen_lines()
+    }
+
+    fn screen_lines(&self) -> usize {
+        self.num_lines as usize
+    }
+
+    fn columns(&self) -> usize {
+        self.num_cols as usize
+    }
+
+    fn last_column(&self) -> Column {
+        Column(self.num_cols as usize - 1)
+    }
+
+    fn bottommost_line(&self) -> Line {
+        Line(self.num_lines as i32 - 1)
+    }
+}
+
+impl From<TerminalSize> for WindowSize {
+    fn from(size: TerminalSize) -> Self {
+        Self {
+            num_lines: size.num_lines,
+            num_cols: size.num_cols,
+            cell_width: size.cell_width,
+            cell_height: size.cell_height,
+        }
+    }
+}