diff --git a/television/app.rs b/television/app.rs
index ab398bc7..5c930417 100644
--- a/television/app.rs
+++ b/television/app.rs
@@ -8,11 +8,10 @@ use crate::{
     keymap::Keymap,
     render::{RenderingTask, UiState, render},
     television::{Mode, Television},
+    tui::{IoStream, Tui, TuiMode},
 };
 use anyhow::Result;
-use crossterm::{
-    cursor, event::MouseEventKind, terminal::size as terminal_size,
-};
+use crossterm::event::MouseEventKind;
 use rustc_hash::FxHashSet;
 use tokio::sync::mpsc;
 use tracing::{debug, error, trace};
@@ -345,14 +344,6 @@ impl App {
         is_output_tty: bool,
         headless: bool,
     ) -> Result<AppOutput> {
-        // Event loop
-        if !headless {
-            debug!("Starting backend event loop");
-            let event_loop = EventLoop::new(self.options.tick_rate);
-            self.event_rx = event_loop.rx;
-            self.event_abort_tx = event_loop.abort_tx;
-        }
-
         // Rendering loop
         if !headless {
             debug!("Starting rendering loop");
@@ -360,29 +351,39 @@ impl App {
             self.render_tx = render_tx.clone();
             let ui_state_tx = self.ui_state_tx.clone();
             let action_tx_r = self.action_tx.clone();
-            let height = if self.options.inline {
-                // Calculate available space for inline mode
-                Self::calculate_inline_height()?
+            let tui_mode = Self::determine_tui_mode(
+                self.options.height,
+                self.options.width,
+                self.options.inline,
+            )?;
+            let stream = if is_output_tty {
+                debug!("Rendering to stdout");
+                IoStream::Stdout.to_stream()
             } else {
-                self.options.height
+                debug!("Rendering to stderr");
+                IoStream::BufferedStderr.to_stream()
             };
-            let width = self.options.width;
+            let mut tui = Tui::new(stream, &tui_mode)
+                .expect("Failed to create TUI instance");
+            debug!("Entering tui");
+            tui.enter().expect("Failed to enter TUI mode");
+
             self.render_task = Some(tokio::spawn(async move {
-                render(
-                    render_rx,
-                    action_tx_r,
-                    ui_state_tx,
-                    is_output_tty,
-                    height,
-                    width,
-                )
-                .await
+                render(render_rx, action_tx_r, ui_state_tx, tui).await
             }));
             self.action_tx
                 .send(Action::Render)
                 .expect("Unable to send init render action.");
         }
 
+        // Event loop
+        if !headless {
+            debug!("Starting backend event loop");
+            let event_loop = EventLoop::new(self.options.tick_rate);
+            self.event_rx = event_loop.rx;
+            self.event_abort_tx = event_loop.abort_tx;
+        }
+
         // Start watch timer if configured
         self.start_watch_timer();
 
@@ -393,8 +394,10 @@ impl App {
         let mut action_buf = Vec::with_capacity(ACTION_BUF_SIZE);
         let mut action_outcome;
 
+        trace!("Entering main event loop");
         loop {
             // handle event and convert to action
+            trace!("Waiting for new events...");
             if self
                 .event_rx
                 .recv_many(&mut event_buf, EVENT_BUF_SIZE)
@@ -410,6 +413,7 @@ impl App {
                     }
                 }
             }
+            trace!("Event buffer processed, handling actions...");
             // It's important that this shouldn't block if no actions are available
             action_outcome = self.handle_actions(&mut action_buf).await?;
 
@@ -447,7 +451,7 @@ impl App {
 
                 // wait for the rendering task to finish
                 if let Some(rendering_task) = self.render_task.take() {
-                    rendering_task.await??;
+                    rendering_task.await?.expect("Rendering task failed");
                 }
 
                 return Ok(AppOutput::new(action_outcome));
@@ -535,7 +539,7 @@ impl App {
         };
 
         if action != Action::Tick {
-            trace!("Converted event to action: {action:?}");
+            trace!("Converted {event:?} to action: {action:?}");
         }
 
         if action == Action::NoOp {
@@ -719,26 +723,76 @@ impl App {
         }
     }
 
-    /// Calculate the height for inline mode.
-    ///
-    /// This method determines the available space at the bottom of the terminal
-    // TODO: revisit minimum height if/when input can be toggled
-    fn calculate_inline_height() -> Result<Option<u16>> {
-        const MIN_HEIGHT: u16 = 6;
-
-        // Get current cursor position and terminal size
-        let (_, current_row) = cursor::position()?;
-        let (_, terminal_height) = terminal_size()?;
-
-        // Calculate available space from next line to bottom of terminal
-        let available_space = terminal_height.saturating_sub(current_row + 1);
-        let ui_height = available_space.max(MIN_HEIGHT);
-
-        debug!(
-            "Inline mode: using {} lines (available: {}, minimum: {})",
-            ui_height, available_space, MIN_HEIGHT
+    /// Determine the TUI mode based on the provided options.
+    fn determine_tui_mode(
+        height: Option<u16>,
+        width: Option<u16>,
+        inline: bool,
+    ) -> Result<TuiMode> {
+        if inline {
+            // Inline mode uses all available space at the bottom of the terminal
+            Ok(TuiMode::Inline)
+        } else if let Some(h) = height {
+            // Fixed mode with specified height and width
+            Ok(TuiMode::Fixed { width, height: h })
+        } else if width.is_some() {
+            // error if width is specified without height
+            Err(anyhow::anyhow!(
+                "TUI viewport: Width cannot be set without a given height."
+            ))
+        } else {
+            // Fullscreen mode
+            Ok(TuiMode::Fullscreen)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_determine_tui_mode() {
+        // Test inline mode
+        assert_eq!(
+            App::determine_tui_mode(None, None, true).unwrap(),
+            TuiMode::Inline,
+            "Passing `inline = true` should return Inline mode"
+        );
+        assert_eq!(
+            App::determine_tui_mode(Some(0), None, true).unwrap(),
+            TuiMode::Inline,
+            "Passing `inline = true` should return Inline mode"
+        );
+        assert_eq!(
+            App::determine_tui_mode(Some(0), Some(0), true).unwrap(),
+            TuiMode::Inline,
+            "Passing `inline = true` should return Inline mode"
+        );
+
+        // Test fixed mode
+        assert_eq!(
+            App::determine_tui_mode(Some(20), Some(80), false).unwrap(),
+            TuiMode::Fixed {
+                width: Some(80),
+                height: 20
+            }
+        );
+        assert_eq!(
+            App::determine_tui_mode(Some(20), None, false).unwrap(),
+            TuiMode::Fixed {
+                width: None,
+                height: 20
+            }
+        );
+
+        // Test fullscreen mode
+        assert_eq!(
+            App::determine_tui_mode(None, None, false).unwrap(),
+            TuiMode::Fullscreen
         );
 
-        Ok(Some(ui_height))
+        // Test error case for width without height
+        assert!(App::determine_tui_mode(None, Some(80), false).is_err());
     }
 }
diff --git a/television/channels/entry.rs b/television/channels/entry.rs
index b97897e6..7138465c 100644
--- a/television/channels/entry.rs
+++ b/television/channels/entry.rs
@@ -126,7 +126,7 @@ impl Entry {
         self.display.as_deref().unwrap_or(&self.raw)
     }
 
-    pub fn stdout_repr(&self, template: &Option<Template>) -> String {
+    pub fn output(&self, template: &Option<Template>) -> String {
         if let Some(template) = template {
             return template.format(&self.raw).unwrap_or_else(|_| {
                 panic!(
@@ -195,7 +195,7 @@ mod tests {
             line_number: None,
         };
         assert_eq!(
-            entry.stdout_repr(&Some(Template::parse("{}").unwrap())),
+            entry.output(&Some(Template::parse("{}").unwrap())),
             "test name with spaces"
         );
     }
diff --git a/television/errors.rs b/television/errors.rs
index 73b19334..1cd13ed0 100644
--- a/television/errors.rs
+++ b/television/errors.rs
@@ -1,4 +1,4 @@
-use crate::tui::Tui;
+use crate::tui::{Tui, TuiMode};
 use anyhow::Result;
 use std::panic;
 use tracing::error;
@@ -6,7 +6,7 @@ use tracing::error;
 pub fn init() -> Result<()> {
     panic::set_hook(Box::new(move |panic_info| {
         // Clean up the terminal
-        if let Ok(mut t) = Tui::new(std::io::stderr(), None, None) {
+        if let Ok(mut t) = Tui::new(std::io::stderr(), &TuiMode::Fullscreen) {
             if let Err(err) = t.exit() {
                 error!("Unable to exit terminal: {:?}", err);
             }
diff --git a/television/main.rs b/television/main.rs
index bb945816..b73c31f3 100644
--- a/television/main.rs
+++ b/television/main.rs
@@ -127,9 +127,7 @@ async fn main() -> Result<()> {
             writeln!(
                 bufwriter,
                 "{}",
-                entry.stdout_repr(
-                    &app.television.channel.prototype.source.output
-                )
+                entry.output(&app.television.channel.prototype.source.output)
             )?;
         }
     }
diff --git a/television/render.rs b/television/render.rs
index 9b9eeade..a75858db 100644
--- a/television/render.rs
+++ b/television/render.rs
@@ -1,3 +1,5 @@
+use std::io::Write;
+
 use crate::{
     action::Action,
     draw::{Ctx, draw},
@@ -9,7 +11,6 @@ use crossterm::{
     execute, queue,
     terminal::{BeginSynchronizedUpdate, EndSynchronizedUpdate},
 };
-use std::io::{LineWriter, stderr, stdout};
 use tokio::sync::mpsc;
 use tracing::{debug, warn};
 
@@ -23,21 +24,6 @@ pub enum RenderingTask {
     Quit,
 }
 
-#[derive(Debug, Clone)]
-enum IoStream {
-    Stdout,
-    BufferedStderr,
-}
-
-impl IoStream {
-    fn to_stream(&self) -> Box<dyn std::io::Write + Send> {
-        match self {
-            IoStream::Stdout => Box::new(stdout()),
-            IoStream::BufferedStderr => Box::new(LineWriter::new(stderr())),
-        }
-    }
-}
-
 #[derive(Default)]
 /// The state of the UI after rendering.
 ///
@@ -72,27 +58,12 @@ const MAX_FRAME_RATE: u128 = 1000 / 60; // 60 FPS
 ///
 /// When starting the rendering loop, a choice is made to either render to stdout or stderr based
 /// on if the output is believed to be a TTY or not.
-pub async fn render(
+pub async fn render<W: Write>(
     mut render_rx: mpsc::UnboundedReceiver<RenderingTask>,
     action_tx: mpsc::UnboundedSender<Action>,
     ui_state_tx: mpsc::UnboundedSender<UiState>,
-    is_output_tty: bool,
-    height: Option<u16>,
-    width: Option<u16>,
+    mut tui: Tui<W>,
 ) -> Result<()> {
-    let stream = if is_output_tty {
-        debug!("Rendering to stdout");
-        IoStream::Stdout.to_stream()
-    } else {
-        debug!("Rendering to stderr");
-        IoStream::BufferedStderr.to_stream()
-    };
-    let mut tui =
-        Tui::new(stream, height, width).expect("Failed to create TUI");
-
-    debug!("Entering tui");
-    tui.enter().expect("Failed to enter TUI mode");
-
     let mut buffer = Vec::with_capacity(256);
     let mut num_instructions;
     let mut frame_start;
diff --git a/television/tui.rs b/television/tui.rs
index 9f0aadda..3a149e88 100644
--- a/television/tui.rs
+++ b/television/tui.rs
@@ -1,5 +1,6 @@
 use std::{
-    io::Write,
+    fs::OpenOptions,
+    io::{BufReader, LineWriter, Read, Write, stderr, stdout},
     ops::{Deref, DerefMut},
 };
 
@@ -14,11 +15,35 @@ use crossterm::{
     },
 };
 use ratatui::{
-    Terminal, TerminalOptions, Viewport, backend::CrosstermBackend,
-    layout::Size,
+    Terminal, TerminalOptions, Viewport,
+    backend::CrosstermBackend,
+    layout::{Position, Size},
+    prelude::Backend,
 };
 use tracing::debug;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TuiMode {
+    Fullscreen,
+    Inline,
+    Fixed { width: Option<u16>, height: u16 },
+}
+
+#[derive(Debug, Clone)]
+pub enum IoStream {
+    Stdout,
+    BufferedStderr,
+}
+
+impl IoStream {
+    pub fn to_stream(&self) -> Box<dyn std::io::Write + Send> {
+        match self {
+            IoStream::Stdout => Box::new(stdout()),
+            IoStream::BufferedStderr => Box::new(LineWriter::new(stderr())),
+        }
+    }
+}
+
 #[allow(dead_code)]
 pub struct Tui<W>
 where
@@ -29,93 +54,147 @@ where
 }
 
 pub const TESTING_ENV_VAR: &str = "TV_TEST";
+pub const MIN_VIEWPORT_HEIGHT: u16 = 15;
 
 #[allow(dead_code)]
 impl<W> Tui<W>
 where
     W: Write,
 {
-    pub fn new(
-        writer: W,
-        height: Option<u16>,
-        width: Option<u16>,
-    ) -> Result<Self> {
+    /// NOTE:
+    /// We use ratatui's `Viewport::Fixed` to handle inline instead of the builtin
+    /// `Viewport::Inline` because we need control over which stream is used to query the cursor
+    /// position and the `Inline` viewport always uses `stdout` under the hood
+    /// (<https://github.com/crossterm-rs/crossterm/blob/master/src/cursor/sys/unix.rs#L35-L36>)
+    /// which makes ratatui (crossterm) panic when trying to read the cursor position from a stream
+    /// that is not connected to a tty.
+    ///
+    /// This allows us to query the cursor position ourselves using `/dev/tty` and to not rely on
+    /// crossterm's current implementation.
+    ///
+    /// More info: <https://github.com/crossterm-rs/crossterm/pull/957>
+    pub fn new(writer: W, mode: &TuiMode) -> Result<Self> {
         let mut backend = CrosstermBackend::new(writer);
         let mut options = TerminalOptions::default();
+        enable_raw_mode()?;
 
-        match (width, height) {
-            (None, None) => {
-                options.viewport = Viewport::Fullscreen;
-            }
-            (None, Some(h)) => {
-                options.viewport = Viewport::Inline(h);
-            }
-            (Some(w), Some(h)) => {
-                // get cursor position
-                let mut cursor_pos = Self::cursor_position()?;
-                let term_size = crossterm::terminal::size()?;
-                // scroll if we don't have enough space
-                if cursor_pos.1 + h > term_size.1 {
+        let terminal_size = backend.size()?;
+        let viewport = match mode {
+            TuiMode::Fullscreen => Viewport::Fullscreen,
+            TuiMode::Inline => {
+                let mut cursor_position = Self::get_cursor_position();
+                // take all available height and max width with a minimum of 15 for the height
+                let available_height =
+                    terminal_size.height.saturating_sub(cursor_position.y);
+                debug!(
+                    "Total height: {}, Available height: {}, cursor position: {:?}",
+                    terminal_size.height, available_height, cursor_position.y
+                );
+                if available_height < MIN_VIEWPORT_HEIGHT {
                     execute!(
                         backend,
-                        ScrollUp(cursor_pos.1 + h - term_size.1)
+                        ScrollUp(MIN_VIEWPORT_HEIGHT - available_height)
                     )?;
-                    cursor_pos.1 = term_size.1.saturating_sub(h);
+                    cursor_position.y = cursor_position.y.saturating_sub(
+                        MIN_VIEWPORT_HEIGHT - available_height + 1,
+                    );
                 }
-                options.viewport =
-                    Viewport::Fixed(ratatui::layout::Rect::new(
-                        cursor_pos.0,
-                        cursor_pos.1,
-                        w.min(term_size.0 - cursor_pos.0),
-                        h.min(term_size.1 - cursor_pos.1),
-                    ));
+                Viewport::Fixed(ratatui::layout::Rect::new(
+                    0,
+                    cursor_position.y,
+                    terminal_size.width,
+                    available_height,
+                ))
             }
-            _ => {
-                return Err(anyhow::anyhow!(
-                    "TUI viewport: Width cannot be set without a given height.",
-                ));
+            TuiMode::Fixed { width, height } => {
+                let mut cursor_position = Self::get_cursor_position();
+                let w = width.unwrap_or(terminal_size.width);
+                let available_height =
+                    terminal_size.height.saturating_sub(cursor_position.y);
+                if available_height < *height {
+                    execute!(backend, ScrollUp(height - available_height))?;
+                    cursor_position.y = cursor_position
+                        .y
+                        .saturating_sub(*height - available_height + 1);
+                }
+                Viewport::Fixed(ratatui::layout::Rect::new(
+                    0,
+                    cursor_position.y,
+                    w.min(terminal_size.width - cursor_position.x),
+                    *height,
+                ))
             }
-        }
+        };
 
-        let viewport = options.viewport.clone();
+        options.viewport = viewport.clone();
         let terminal = Terminal::with_options(backend, options)?;
         Ok(Self { terminal, viewport })
     }
 
-    pub fn cursor_position() -> Result<(u16, u16)> {
+    pub fn size(&self) -> Result<Size> {
+        Ok(self.terminal.size()?)
+    }
+
+    const DSR: &'static str = "\x1b[6n";
+    /// This is manually implemented as a workaround to a [crossterm issue](https://github.com/crossterm-rs/crossterm/pull/957).
+    ///
+    /// See the `Tui::new` method for more details.
+    fn get_cursor_position() -> Position {
         if std::env::var(TESTING_ENV_VAR).is_ok() {
-            // For testing purposes, return a fixed position
-            return Ok((0, 0));
+            // In tests, return a fixed position
+            return Position { x: 0, y: 0 };
         }
-        crossterm::cursor::position().map_err(|e| {
-            anyhow::anyhow!("Failed to get cursor position: {}", e)
-        })
-    }
+        let mut tty = OpenOptions::new()
+            .read(true)
+            // .write(true)
+            .append(true)
+            .open("/dev/tty")
+            .expect("Failed to open /dev/tty");
 
-    pub fn size(&self) -> Result<Size> {
-        Ok(self.terminal.size()?)
+        writeln!(tty, "{}", Self::DSR).expect("Failed to write to /dev/tty");
+
+        let mut response = Vec::new();
+        for byte in BufReader::new(tty).bytes() {
+            match byte {
+                Ok(b'R') => break,       // End of response
+                Ok(b'\x1B' | b'[') => {} // Ignore CSI sequences
+                Ok(b) => response.push(b),
+                Err(e) => panic!("Error reading from /dev/tty: {}", e),
+            }
+        }
+
+        let pos = response.split(|e| *e == b';').collect::<Vec<_>>();
+        if pos.len() == 2 {
+            let x =
+                String::from_utf8_lossy(pos[1]).parse::<u16>().unwrap_or(0);
+            let y =
+                String::from_utf8_lossy(pos[0]).parse::<u16>().unwrap_or(0);
+            Position {
+                x: x.saturating_sub(1),
+                y: y.saturating_sub(1),
+            } // Convert to zero-based index
+        } else {
+            Position::default() // Default position if parsing fails
+        }
     }
 
     pub fn resize_viewport(&mut self, w: u16, h: u16) -> Result<()> {
         debug!("Resizing viewport to: {:?}", (w, h));
-        let layout = match self.viewport {
-            Viewport::Fullscreen | Viewport::Inline(_) => {
-                ratatui::layout::Rect::new(0, 0, w, h)
-            }
-            Viewport::Fixed(rect) => ratatui::layout::Rect::new(
-                rect.x,
-                rect.y,
-                w.min(rect.width),
-                h.min(rect.height),
-            ),
-        };
+        // simpler implementation: just resize the terminal to the new size
+        // yes, we lose the previous data from the terminal, but that's an
+        // acceptable trade-off for the sake of simplicity
+        let layout = ratatui::layout::Rect::new(0, 0, w, h);
+
+        // Update the stored viewport and only if it's not fullscreen
+        if self.viewport != Viewport::Fullscreen {
+            self.viewport = Viewport::Fixed(layout);
+        }
+        self.terminal.resize(layout)?;
 
-        self.resize(layout)?;
         Ok(())
     }
 
     pub fn enter(&mut self) -> Result<()> {
-        enable_raw_mode()?;
         let backend = self.terminal.backend_mut();
 
         execute!(backend, EnableMouseCapture)?;
diff --git a/television/utils/input.rs b/television/utils/input.rs
index 5a4bd7b4..83d5843d 100644
--- a/television/utils/input.rs
+++ b/television/utils/input.rs
@@ -414,13 +414,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn format() {
-        let input: Input = TEXT.into();
-        println!("{}", input);
-        println!("{}", input);
-    }
-
     #[test]
     fn set_cursor() {
         let mut input: Input = TEXT.into();
diff --git a/television/utils/shell/completion.bash b/television/utils/shell/completion.bash
index 8a2bae7e..ab2614b1 100644
--- a/television/utils/shell/completion.bash
+++ b/television/utils/shell/completion.bash
@@ -2,7 +2,7 @@ function tv_smart_autocomplete() {
   # prefix (lhs of cursor)
   local current_prompt="${READLINE_LINE:0:$READLINE_POINT}"
 
-  local output=$(tv --autocomplete-prompt "$current_prompt" | tr '\n' ' ')
+  local output=$(tv --autocomplete-prompt "$current_prompt" --inline | tr '\n' ' ')
 
   if [[ -n $output ]]; then
     # suffix (rhs of cursor)
@@ -19,7 +19,7 @@ function tv_smart_autocomplete() {
 function tv_shell_history() {
   local current_prompt="${READLINE_LINE:0:$READLINE_POINT}"
 
-  local output=$(tv bash-history --input "$current_prompt")
+  local output=$(tv bash-history --input "$current_prompt" --inline)
 
   if [[ -n $output ]]; then
     READLINE_LINE=$output
diff --git a/television/utils/shell/completion.fish b/television/utils/shell/completion.fish
index c2596f42..42f2f9c8 100644
--- a/television/utils/shell/completion.fish
+++ b/television/utils/shell/completion.fish
@@ -95,7 +95,7 @@ function tv_smart_autocomplete
     # prefix (lhs of cursor)
     set -l current_prompt (commandline --current-process)
 
-    if set -l result (tv $dir --autocomplete-prompt "$current_prompt" --input $tv_query)
+    if set -l result (tv $dir --autocomplete-prompt "$current_prompt" --input $tv_query --inline)
         # Remove last token from commandline.
         commandline -t ''
 
diff --git a/television/utils/shell/completion.nu b/television/utils/shell/completion.nu
index 477c32d3..4d4faf37 100644
--- a/television/utils/shell/completion.nu
+++ b/television/utils/shell/completion.nu
@@ -3,7 +3,7 @@ def tv_smart_autocomplete [] {
     let cursor = (commandline get-cursor)
     let current_prompt = ($current_prompt | str substring 0..$cursor)
  
-    let output = (tv --autocomplete-prompt $current_prompt | str trim)
+    let output = (tv --autocomplete-prompt $current_prompt --inline | str trim)
 
     if ($output | str length) > 0 {
         let needs_space = not ($current_prompt | str ends-with " ")
@@ -22,7 +22,7 @@ def tv_shell_history [] {
     let cursor = (commandline get-cursor)
     let current_prompt = ($current_prompt | str substring 0..$cursor)
     
-    let output = (tv nu-history --input $current_prompt | str trim)
+    let output = (tv nu-history --input $current_prompt --inline | str trim)
 
     if ($output | is-not-empty) {
         commandline edit --replace $output
diff --git a/television/utils/shell/completion.zsh b/television/utils/shell/completion.zsh
index 043709f7..54e7f415 100644
--- a/television/utils/shell/completion.zsh
+++ b/television/utils/shell/completion.zsh
@@ -32,7 +32,7 @@ __tv_path_completion() {
       [ "$dir" != "/" ] && dir="${dir/%\//}"
       matches=$(
         shift
-        tv "$dir" --autocomplete-prompt "$lbuf" --input "$leftover" < /dev/tty | while read -r item; do
+        tv "$dir" --autocomplete-prompt "$lbuf" --inline --input "$leftover" < /dev/tty | while read -r item; do
           item="${item%$suffix}$suffix"
           dirP="$dir/"
           [[ $dirP = "./" ]] && dirP=""
@@ -92,7 +92,7 @@ _tv_shell_history() {
 
     local output
 
-    output=$(history -n -1 0 | tv --input "$current_prompt" $*)
+    output=$(history -n -1 0 | tv --input "$current_prompt" --inline $*)
 
     if [[ -n $output ]]; then
         zle reset-prompt