diff --git a/.gitignore b/.gitignore
index 3a4e4af..c5d14d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,4 +27,5 @@ target
 Cargo.lock
 
 # Logs
-*.log
\ No newline at end of file
+*.log
+docs/vimstoat/book*/
diff --git a/Cargo.toml b/Cargo.toml
index 4d58b56..67e1244 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,12 +18,22 @@ pickledb = { version = "0.5.1", features = ["bincode"] }
 # Directories
 dirs = "6.0.0"
 
+# Notifications
+notify-rust = "4.18.0"
+# WebSockets
+tokio-tungstenite = { version = "0.30.0", features = ["native-tls"] }
+futures-util = "0.3.31"
+
 keyring-lib = { version = "1.0.3", features = ["tokio"] }
 ratatui = "0.30.2"
-reqwest = { version = "0.13.4", default-features = false, features = ["json"] }
+reqwest = { version = "0.13.4", default-features = false, features = [
+  "json",
+  "rustls",
+] }
 serde = { version = "1", features = ["derive"] }
 tokio = { version = "1.52.3", features = ["full"] }
 serde_json = "1.0.150"
+ulid = "3.0.0"
 
 [dev-dependencies]
 cargo-husky = { version = "1.5.0", default-features = false, features = [
diff --git a/README.md b/README.md
index 495004a..d6df6cb 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 A lightweight TUI [Stoat](https://stoat.chat) client that feels like Vim.
 
-> **Status:** Early development — see [ROADMAP.md](ROADMAP.md) for the full plan.
+> **Status:** Early development — see our [Documentation](docs/vimstoat/src/SUMMARY.md) for features and keybinds.
 
 ## What is this?
 
diff --git a/ROADMAP.md b/ROADMAP.md
deleted file mode 100644
index b43d340..0000000
--- a/ROADMAP.md
+++ /dev/null
@@ -1,557 +0,0 @@
-# VimStoat — Project Roadmap
-
-> A lightweight, Vim-flavored TUI client for [Stoat.chat](https://stoat.chat)
-> Built in Rust with Ratatui. Designed to feel like home for Vim users.
-
----
-
-## Table of Contents
-
-- [Vision](#vision)
-- [Architecture Decision: Pure Rust vs Hybrid](#architecture-decision-pure-rust-vs-hybrid)
-- [Authentication Strategy](#authentication-strategy)
-- [Project Structure](#project-structure)
-- [Vim Modal System](#vim-modal-system)
-- [Keybinding Reference](#keybinding-reference)
-- [Roadmap Phases](#roadmap-phases)
-- [API Surface We Need](#api-surface-we-need)
-- [Prior Art & Inspiration](#prior-art--inspiration)
-
----
-
-## Vision
-
-VimStoat is a terminal-first Stoat chat client that treats Vim keybindings as a first-class citizen — not an afterthought bolted onto a generic TUI. The goal is a client where a Vim user can navigate servers, channels, and messages entirely from muscle memory: `j`/`k` to scroll, `i` to compose, `Esc` to stop, `/` to search, `:q` to quit.
-
-**What this is NOT:**
-
-- A bot framework (that's what `stoat-rs` is for)
-- A full reimplementation of the web client
-- A project that needs every feature on day one
-
-**What this IS:**
-
-- A fast, keyboard-driven chat client
-- Opinionated about UX — Vim's modal paradigm applied to chat
-- A single static binary with zero runtime dependencies
-
----
-
-## Architecture Decision: Pure Rust vs Hybrid
-
-There's been discussion about two possible architectures. Here's an honest breakdown.
-
-### Option A: Pure Rust (Recommended)
-
-```
-┌─────────────────────────────┐
-│         vimstoat            │
-│  ┌───────────┐ ┌──────────┐ │
-│  │  Ratatui  │ │  reqwest  │ │
-│  │  (TUI)    │ │  (HTTP)   │ │
-│  └───────────┘ └──────────┘ │
-│  ┌───────────┐ ┌──────────┐ │
-│  │ crossterm │ │ tungstenite│ │
-│  │  (input)  │ │  (WS)    │ │
-│  └───────────┘ └──────────┘ │
-│         Single Binary        │
-└─────────────────────────────┘
-```
-
-**The Stoat/Revolt REST API is simple.** Looking at the actual endpoints we need (listed below in [API Surface](#api-surface-we-need)), we're talking about ~15 REST calls that are all `GET`/`POST`/`PATCH`/`DELETE` with JSON bodies. This is trivial to implement with `reqwest`. The WebSocket protocol is a single connection that sends/receives JSON events. `tokio-tungstenite` handles this cleanly.
-
-| Pros                                       | Cons                                                      |
-| ------------------------------------------ | --------------------------------------------------------- |
-| Single binary, zero runtime deps           | Must hand-write API types (or pull `revolt-models` crate) |
-| No IPC overhead, no serialization boundary | WebSocket reconnection logic is on us                     |
-| Simpler deployment (`cargo install`)       | No access to JS ecosystem libraries                       |
-| Everything is type-safe end-to-end         | If API changes, we update manually                        |
-| Tokio async works perfectly with ratatui   |                                                           |
-| No Node.js/npm/Bun dependency for users    |                                                           |
-
-**Why stoat-rs isn't the answer:** The SDK is bot-centric — it uses `X-Bot-Token`, wraps everything in a `Client::new(EventHandler).run()` pattern that assumes you're building a bot, and the WebSocket layer is tightly coupled to that. For a user-facing TUI, we'd fight the SDK at every turn. However, the `revolt-models` crate (which `stoat-rs` re-exports as `stoat-models`) contains all the API type definitions and is perfectly usable standalone.
-
-### Option B: Rust TUI + TypeScript API Backend
-
-```
-┌──────────────┐     IPC      ┌────────────────┐
-│  Rust TUI    │◄────────────►│  Node/Bun      │
-│  (Ratatui)   │  JSON-RPC    │  (stoat-api)   │
-│  (crossterm) │  over stdin/ │  (revolt.js)   │
-│              │  stdout or   │                │
-│              │  unix socket │                │
-└──────────────┘              └────────────────┘
-   Process A                     Process B
-```
-
-The idea: let TypeScript handle the Stoat API (since `revolt.js`/`stoat-api` are the best-maintained client libraries with full WebSocket support, caching, and state management built in), and let Rust handle the TUI rendering.
-
-| Pros                                                           | Cons                                                               |
-| -------------------------------------------------------------- | ------------------------------------------------------------------ |
-| `revolt.js` has battle-tested WS handling, caching, reactivity | **Two processes** — must manage lifecycle, crashes, zombies        |
-| API types are always in sync with upstream                     | Serialization overhead on every message/event                      |
-| If Stoat API changes, npm update fixes it                      | Users need Node.js/Bun installed — kills "single binary" story     |
-| Richer ecosystem for API edge cases                            | Debugging across process boundary is painful                       |
-|                                                                | JSON-RPC or IPC protocol is a whole sub-project to design          |
-|                                                                | Latency: every keypress → IPC → TS → API → response → IPC → render |
-|                                                                | Massively more complex build/packaging/distribution                |
-
-**A middle-ground variant** would be `napi-rs` (Rust as a native Node addon, running in-process). This eliminates the IPC overhead but still requires Node.js at runtime. It's great for Electron/Tauri apps but awkward for a pure TUI — you'd be embedding a Node runtime just for HTTP calls.
-
-### Verdict
-
-**Go pure Rust.** The API surface is small enough that the "better JS libraries" argument doesn't hold up against the massive complexity tax of a hybrid architecture. We'd spend more time building and debugging the IPC bridge than we would writing 15 HTTP endpoints in Rust. The `revolt-models` crate gives us the types for free, and `reqwest` + `tokio-tungstenite` cover our networking needs.
-
-If `revolt-models` ever becomes unmaintained, we can generate Rust types from the OpenAPI spec that Stoat publishes via `stoatchat/javascript-client-api`.
-
----
-
-## Authentication Strategy
-
-Stoat officially recommends that third-party clients **do not handle usernames and passwords**. Users obtain their session token from the web client and paste it into VimStoat. This is the same approach used by other third-party Revolt/Stoat clients.
-
-### How It Works
-
-1. User logs into Stoat web client
-2. Opens browser DevTools → Application → Local Storage
-3. Copies their session token
-4. Pastes it into VimStoat on first launch
-5. VimStoat stores it securely in the OS keyring via `keyring-lib`
-6. On subsequent launches, token is loaded from keyring automatically
-
-### Token Validation
-
-Currently we accept any string as a token. We need to validate it by calling `GET /users/@me` with the token as `X-Session-Token`. If it returns a `User` object, the token is valid. If it returns 401, we prompt again.
-
-### Auth Headers
-
-| Client Type  | Header            | Our Case    |
-| ------------ | ----------------- | ----------- |
-| Bot          | `X-Bot-Token`     | ❌ Not us   |
-| User session | `X-Session-Token` | ✅ This one |
-
-### Instance Configuration
-
-The base URL should be configurable to support self-hosted instances:
-
-- Default: `https://api.stoat.chat`
-- Configurable via: `~/.config/vimstoat/config.toml` or `--instance` CLI flag
-
----
-
-## Project Structure
-
-The current codebase is 3 files. Here's where we need to go:
-
-```
-vimstoat/
-├── Cargo.toml
-├── README.md
-├── ROADMAP.md              ← you are here
-├── config.example.toml     ← example user config
-│
-└── src/
-    ├── main.rs             ← entry point: init terminal, run event loop, restore
-    ├── app.rs              ← root App struct, owns all state, dispatches actions
-    ├── action.rs           ← Action enum: every possible state mutation
-    ├── input.rs            ← (Mode, KeyEvent) → Vec<Action>, pending-key buffer
-    ├── tui.rs              ← terminal init/restore, panic hooks, alternate screen
-    ├── event.rs            ← async event source: keys, ticks, API events via mpsc
-    ├── error.rs            ← AppError enum (thiserror), Result<T> alias
-    ├── config.rs           ← instance URL, theme, keybind overrides
-    │
-    ├── api/
-    │   ├── mod.rs
-    │   ├── client.rs       ← StoatApi struct: thin reqwest wrapper
-    │   ├── auth.rs         ← token validation, keyring read/write
-    │   └── ws.rs           ← WebSocket connection, event stream
-    │
-    ├── state/
-    │   ├── mod.rs
-    │   ├── chat.rs         ← server/channel/message/user caches
-    │   └── ui.rs           ← scroll offsets, selections, panel focus
-    │
-    └── components/
-        ├── mod.rs          ← Component trait definition
-        ├── login.rs        ← token input screen
-        ├── server_list.rs  ← left sidebar
-        ├── channel_list.rs ← channel panel
-        ├── message_view.rs ← main message area (scrollable)
-        ├── message_input.rs← compose bar (Insert mode target)
-        ├── command_line.rs ← ":" command bar
-        └── status_bar.rs  ← mode indicator + context info
-```
-
-### Core Design Pattern
-
-**Component + Action Dispatch** (ratatui community best practice):
-
-```
- Crossterm KeyEvent
-       │
-       ▼
- ┌─────────────┐
- │  input.rs   │  Pure function: (Mode, Key) → Actions
- └──────┬──────┘
-        │ Vec<Action>
-        ▼
- ┌─────────────┐
- │   app.rs    │  match action { ... } → mutate state
- └──────┬──────┘
-        │ &AppState
-        ▼
- ┌─────────────┐
- │ components/ │  Pure rendering: (&State, Rect) → Frame
- └─────────────┘
-```
-
-State flows down. Events flow up as Actions. No component directly mutates state. This keeps everything testable and predictable.
-
-### Key Dependencies
-
-| Crate                    | Purpose                  | Replaces               |
-| ------------------------ | ------------------------ | ---------------------- |
-| `ratatui`                | TUI framework            | (keep)                 |
-| `crossterm`              | terminal backend & input | (implicit via ratatui) |
-| `tokio`                  | async runtime            | (keep)                 |
-| `reqwest` (json feature) | HTTP client              | `stoat-rs`             |
-| `revolt-models`          | API type definitions     | `stoat-rs` re-exports  |
-| `tokio-tungstenite`      | WebSocket client         | —                      |
-| `keyring-lib`            | secure token storage     | (keep)                 |
-| `thiserror`              | error types              | `Box<dyn Error>`       |
-| `serde` / `serde_json`   | JSON serialization       | —                      |
-| `directories`            | XDG config paths         | —                      |
-| `toml`                   | config file parsing      | —                      |
-
----
-
-## Vim Modal System
-
-### Modes
-
-```rust
-enum Mode {
-    Normal,   // Default. Navigate, scroll, select.
-    Insert,   // Typing a message. Input goes to compose bar.
-    Command,  // ":" prefix. Commands like :quit, :join, :help.
-    Visual,   // Future. Select text or messages.
-}
-```
-
-The mode is always visible in the status bar: `-- NORMAL --`, `-- INSERT --`, etc.
-
-### Mode Transitions
-
-```
-                    ┌──────────┐
-          ┌────i────│  NORMAL  │────:────┐
-          │    a    │ (default)│         │
-          │    o    └────┬─────┘         │
-          ▼              │               ▼
-    ┌──────────┐    v (future)    ┌───────────┐
-    │  INSERT  │         │        │  COMMAND  │
-    │          │         ▼        │           │
-    └────┬─────┘   ┌──────────┐  └─────┬─────┘
-         │         │  VISUAL  │        │
-         │         └────┬─────┘        │
-         │              │              │
-         └──── Esc ─────┴──── Esc ─────┘
-                    (back to Normal)
-```
-
-### Pending Key Buffer
-
-Vim has multi-key commands: `gg`, `dd`, `yy`, `Ctrl+w h`. We need a small state machine:
-
-```rust
-struct PendingKey {
-    keys: Vec<KeyEvent>,
-    timeout: Duration,    // reset if no follow-up within ~500ms
-}
-```
-
-When `g` is pressed in Normal mode, we buffer it and wait. If `g` comes again within the timeout → `Action::JumpToTop`. If timeout expires or a different key comes → flush buffer as individual keys.
-
----
-
-## Keybinding Reference
-
-### Normal Mode — Navigation & Actions
-
-**Movement:**
-| Key | Action |
-|-----|--------|
-| `j` / `↓` | Select next item (channel, message) |
-| `k` / `↑` | Select previous item |
-| `h` / `←` | Focus panel left (servers ← channels ← messages) |
-| `l` / `→` | Focus panel right |
-| `gg` | Jump to top of list |
-| `G` | Jump to bottom (most recent) |
-| `Ctrl+d` | Half-page scroll down |
-| `Ctrl+u` | Half-page scroll up |
-| `Ctrl+f` | Full page down |
-| `Ctrl+b` | Full page up |
-| `H` | Top of visible area |
-| `M` | Middle of visible area |
-| `L` | Bottom of visible area |
-
-**Mode switching:**
-| Key | Action |
-|-----|--------|
-| `i` | Enter Insert mode (focus input bar) |
-| `I` | Enter Insert mode, cursor at start |
-| `a` | Enter Insert mode, cursor after current pos |
-| `A` | Enter Insert mode, cursor at end |
-| `o` | Enter Insert mode, start new message |
-| `:` | Enter Command mode |
-| `/` | Search (enters Command mode with `/` prefix) |
-| `v` | Enter Visual mode (future) |
-
-**Actions on messages:**
-| Key | Action |
-|-----|--------|
-| `Enter` | Open/select (enter channel, expand thread) |
-| `r` | Reply to selected message |
-| `e` | Edit message (if yours) |
-| `dd` | Delete message (if yours, with confirmation) |
-| `yy` | Copy message content to clipboard |
-| `n` | Next search result |
-| `N` | Previous search result |
-
-**Window management:**
-| Key | Action |
-|-----|--------|
-| `Tab` | Cycle focus to next panel |
-| `Shift+Tab` | Cycle focus to previous panel |
-| `Ctrl+w h` | Focus panel left |
-| `Ctrl+w j` | Focus panel below |
-| `Ctrl+w k` | Focus panel above |
-| `Ctrl+w l` | Focus panel right |
-
-**General:**
-| Key | Action |
-|-----|--------|
-| `q` | Quit |
-| `Ctrl+c` | Quit |
-| `Ctrl+l` | Force redraw |
-
-### Insert Mode — Composing Messages
-
-| Key               | Action                         |
-| ----------------- | ------------------------------ |
-| `Esc` / `Ctrl+[`  | Back to Normal mode            |
-| `Enter`           | Send message                   |
-| `Ctrl+c`          | Cancel, back to Normal         |
-| `Backspace`       | Delete character before cursor |
-| `Ctrl+w`          | Delete word before cursor      |
-| `Ctrl+u`          | Clear entire input line        |
-| `Home` / `Ctrl+a` | Cursor to start of input       |
-| `End` / `Ctrl+e`  | Cursor to end of input         |
-| `Ctrl+←`          | Move cursor one word left      |
-| `Ctrl+→`          | Move cursor one word right     |
-| All other chars   | Insert into message            |
-
-### Command Mode — `:` Commands
-
-| Command                 | Action                                |
-| ----------------------- | ------------------------------------- |
-| `:q` / `:quit`          | Quit the application                  |
-| `:w`                    | Not applicable (but could save draft) |
-| `:wq`                   | Send current draft and quit           |
-| `:join <channel>`       | Switch to channel                     |
-| `:server <name>`        | Switch to server                      |
-| `:reply`                | Reply to selected message             |
-| `:edit`                 | Edit selected message                 |
-| `:delete`               | Delete selected message               |
-| `:search <term>`        | Search messages in current channel    |
-| `:set <option> <value>` | Change a setting                      |
-| `:help`                 | Show keybinding help overlay          |
-| `:mark <name>`          | Bookmark current position (future)    |
-| `Esc`                   | Cancel, back to Normal                |
-| `Enter`                 | Execute command                       |
-| `Tab`                   | Autocomplete command/argument         |
-| `↑` / `↓`               | Command history                       |
-
----
-
-## Roadmap Phases
-
-### Phase 0: Cleanup (Current → Foundation)
-
-**Goal:** Restructure the existing code into the target architecture without adding features.
-
-- [ ] Create `error.rs` with proper `AppError` enum (replace `Box<dyn Error>`)
-- [ ] Create `tui.rs` (extract terminal init/restore from main)
-- [ ] Create `action.rs` with initial `Action` enum
-- [ ] Create `input.rs` — wire up mode-based key dispatch
-- [ ] Create `event.rs` — async event channel
-- [ ] Refactor `app.rs` — separate auth state from UI mode
-- [ ] Move login UI to `components/login.rs`
-- [ ] Create `components/status_bar.rs` with mode indicator
-- [ ] Implement `Mode` enum and mode transitions (Normal/Insert/Command)
-- [ ] Add `Cargo.toml` dependencies, remove `stoat-rs`
-- [ ] Validate token on entry with `GET /users/@me`
-
-**Deliverable:** App compiles, launches, shows mode in status bar, `i`/`Esc`/`:q` all work. Token is validated against the real API.
-
----
-
-### Phase 1: See Your Chats
-
-**Goal:** Connect to Stoat and display real data.
-
-- [ ] Create `api/client.rs` — `StoatApi` struct wrapping `reqwest`
-- [ ] Create `api/auth.rs` — token validation + keyring integration
-- [ ] Create `state/chat.rs` — server/channel/message cache
-- [ ] Create `state/ui.rs` — scroll positions, selected indices, focus
-- [ ] `components/server_list.rs` — fetch and render server sidebar
-- [ ] `components/channel_list.rs` — channels for selected server
-- [ ] `components/message_view.rs` — scrollable message history
-- [ ] `components/message_input.rs` — compose bar with Insert mode
-- [ ] Wire up `j`/`k` navigation in all panels
-- [ ] Wire up `h`/`l` panel focus switching
-- [ ] Wire up `gg`/`G` jump to top/bottom
-- [ ] Wire up `Ctrl+d`/`Ctrl+u` scrolling
-- [ ] Implement message sending via Insert mode + Enter
-
-**Deliverable:** You can launch VimStoat, see your servers and channels, read messages, navigate with Vim keys, and send messages.
-
----
-
-### Phase 2: Real-Time
-
-**Goal:** Messages appear live without manual refresh.
-
-- [ ] Create `api/ws.rs` — WebSocket connection to Stoat events endpoint
-- [ ] Handle `Authenticate` handshake with session token
-- [ ] Handle incoming events: new messages, edits, deletes
-- [ ] Handle typing indicators (show who's typing)
-- [ ] Handle presence updates (online/offline/idle)
-- [ ] Implement reconnection logic with exponential backoff
-- [ ] Integrate WS events into the event channel (`event.rs`)
-- [ ] Update message cache reactively on WS events
-- [ ] Send typing indicator when user is composing
-
-**Deliverable:** VimStoat feels alive — messages from other users appear instantly, typing indicators show, presence is visible.
-
----
-
-### Phase 3: Power User Features
-
-**Goal:** The features that make a Vim user grin.
-
-- [ ] Message actions: reply (`r`), edit (`e`), delete (`dd`)
-- [ ] Yank message content to clipboard (`yy`)
-- [ ] Search messages (`/` and `:search`)
-- [ ] `n`/`N` to navigate search results
-- [ ] Command history in Command mode (↑/↓)
-- [ ] Tab completion for commands and channel names
-- [ ] `:help` overlay showing all keybindings
-- [ ] Configurable keybindings via `config.toml`
-- [ ] Configurable instance URL
-- [ ] Theme/color scheme configuration
-- [ ] Notification indicators (unread channels)
-- [ ] Mark channels as read
-
-**Deliverable:** VimStoat is genuinely usable as a daily driver for basic chat.
-
----
-
-### Phase 4: Polish & Beyond
-
-**Goal:** Go from "usable" to "I prefer this over the web client."
-
-- [ ] Visual mode for selecting text/messages
-- [ ] Multi-line message composition
-- [ ] File/image upload support
-- [ ] Image preview (sixel/kitty protocol for supported terminals)
-- [ ] Emoji reactions
-- [ ] User profiles and member lists
-- [ ] Thread support
-- [ ] DM conversations
-- [ ] Marks and jump list (like Vim's `'a`, `Ctrl+o`, `Ctrl+i`)
-- [ ] Registers (clipboard history)
-- [ ] Plugin system (Lua scripting?)
-- [ ] Man page and shell completions
-- [ ] CI/CD: GitHub Actions for builds + releases
-- [ ] AUR / Homebrew / Nix package
-
----
-
-## API Surface We Need
-
-This is every Stoat REST endpoint VimStoat needs, organized by phase. This is why writing our own client is tractable — it's only ~20 endpoints total.
-
-### Phase 1 (Core)
-
-| Method | Endpoint                  | Purpose                                 |
-| ------ | ------------------------- | --------------------------------------- |
-| `GET`  | `/`                       | Fetch instance config (WS URL, CDN URL) |
-| `GET`  | `/users/@me`              | Validate token, get own user info       |
-| `GET`  | `/users/{id}`             | Fetch user details                      |
-| `GET`  | `/users/dms`              | Fetch DM channel list                   |
-| `GET`  | `/servers/{id}`           | Fetch server details + channels         |
-| `GET`  | `/channels/{id}`          | Fetch channel details                   |
-| `GET`  | `/channels/{id}/messages` | Fetch message history (paginated)       |
-| `POST` | `/channels/{id}/messages` | Send a message                          |
-
-### Phase 2 (WebSocket)
-
-| Event                | Direction       | Purpose                 |
-| -------------------- | --------------- | ----------------------- |
-| `Authenticate`       | Client → Server | Auth with session token |
-| `Ready`              | Server → Client | Initial state dump      |
-| `Message`            | Server → Client | New message received    |
-| `MessageUpdate`      | Server → Client | Message edited          |
-| `MessageDelete`      | Server → Client | Message deleted         |
-| `ChannelStartTyping` | Both            | Typing indicators       |
-
-### Phase 3 (Extended)
-
-| Method   | Endpoint                                         | Purpose              |
-| -------- | ------------------------------------------------ | -------------------- |
-| `PATCH`  | `/channels/{id}/messages/{id}`                   | Edit own message     |
-| `DELETE` | `/channels/{id}/messages/{id}`                   | Delete own message   |
-| `GET`    | `/channels/{id}/messages/search`                 | Search messages      |
-| `PUT`    | `/channels/{id}/ack/{id}`                        | Mark channel as read |
-| `GET`    | `/users/{id}/profile`                            | User profile info    |
-| `PUT`    | `/channels/{id}/messages/{id}/reactions/{emoji}` | React to message     |
-
-### Auth Header (All Requests)
-
-```
-X-Session-Token: <user's session token>
-```
-
----
-
-## Prior Art & Inspiration
-
-Projects and tools that inform VimStoat's design:
-
-| Project                                                            | What We Learn From It                                                                                    |
-| ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
-| [WeeChat](https://weechat.org/)                                    | The gold standard for terminal chat. Buffer-based architecture, plugin system, keybinding customization. |
-| [senpai](https://sr.ht/~delthas/senpai/)                           | IRC TUI in Go. Clean, minimal, good UX for a chat TUI.                                                   |
-| [ncspot](https://github.com/hrkfdn/ncspot)                         | Spotify TUI in Rust (ratatui). Great reference for async API integration + Vim-like navigation.          |
-| [lazygit](https://github.com/jesseduffield/lazygit)                | Git TUI. Excellent panel navigation and keybinding design.                                               |
-| [Neovim](https://neovim.io/)                                       | The modal editing model we're emulating. Pending keys, operator-motion, modes.                           |
-| [revolt.js](https://github.com/revoltchat/revolt.js)               | Reference for how the WebSocket protocol and caching should work.                                        |
-| [ratatui component template](https://github.com/ratatui/templates) | The project structure and patterns we're following.                                                      |
-
----
-
-## Contributing
-
-This project is in early development. If you're interested in contributing:
-
-1. Read this roadmap
-2. Check the phase we're currently on
-3. Pick an unchecked item
-4. Open a PR
-
-The architecture is designed so that components are independent — you can build `server_list.rs` without touching `message_view.rs`.
-
----
-
-_Last updated: July 2025_
diff --git a/docs/vimstoat/src/SUMMARY.md b/docs/vimstoat/src/SUMMARY.md
index dc9a9a8..512e34e 100644
--- a/docs/vimstoat/src/SUMMARY.md
+++ b/docs/vimstoat/src/SUMMARY.md
@@ -1,3 +1,4 @@
 # Summary
 
+- [Features](./features.md)
 - [Keybinds](./keybinds.md)
diff --git a/docs/vimstoat/src/features.md b/docs/vimstoat/src/features.md
new file mode 100644
index 0000000..40cd001
--- /dev/null
+++ b/docs/vimstoat/src/features.md
@@ -0,0 +1,20 @@
+# Features
+
+VimStoat is currently in early development. Here are the features implemented so far:
+
+## Real-time Messaging
+- **WebSocket Integration**: Listens for real-time `Message`, `MessageUpdate`, and `MessageDelete` events from the server.
+- **Dynamic Author Resolution**: Transparently fetches and caches unknown user profiles to display real usernames instead of raw IDs in the UI.
+- **In-Memory Cache**: Uses an in-memory cache synchronized to disk upon application exit for maximum performance.
+
+## Direct Messages
+- **DM List View**: Displays all active Direct Message channels.
+- **Unread Indicators**: Channels with new messages are automatically marked with a red `[*]` unread indicator.
+- **Message Previews**: The DM list shows a truncated preview of the latest message for each channel.
+- **Chat Interface**: View message history and send new messages seamlessly via the REST API.
+
+## Vim-Native Interface
+- **Mode-Specific UI Themes**: Border colors dynamically shift based on the current mode (e.g., Yellow for Insert mode, Blue for UI/Normal mode).
+- **Cursor Shaping**: Hardware cursor shape changes depending on mode (e.g., blinking bar in Insert mode, block in Normal mode).
+- **Input Motions**: Features robust vim-like text composition motions like `i`, `I`, `a`, `A`, `o`, `O`, `dd` (delete line), and an in-memory yank buffer.
+- **Screen Navigation**: Use `q` or `:q` to navigate back through screens, and `:qa` to quit globally.
diff --git a/docs/vimstoat/src/keybinds.md b/docs/vimstoat/src/keybinds.md
index d6fa648..7b16319 100644
--- a/docs/vimstoat/src/keybinds.md
+++ b/docs/vimstoat/src/keybinds.md
@@ -19,11 +19,21 @@
 | `A`   | Enter Insert mode, at the end of the line                        |
 | `o`   | Enter Insert mode, and create a new line below the current line. |
 | `O`   | Enter Insert mode, and create a new line above the current line. |
+| `dd`  | Delete the current line                                          |
+| `gg`  | Go to the top of the UI list                                     |
+| `q`   | Go back or Quit                                                  |
 | `:`   | Enter Command mode                                               |
 | `/`   | Search (enters Command mode with `/` prefix)                     |
 | `v`   | Enter Visual mode (future)                                       |
 | `Esc` | Enter Normal mode                                                |
 
+## Commands (Command Mode)
+
+| Command        | Action                                                           |
+| -------------- | ---------------------------------------------------------------- |
+| `:q`, `:quit`  | Go back to the previous screen, or quit if at the top level      |
+| `:qa`, `:qall` | Quit the application immediately                                 |
+
 ## Fuzzy Finder
 
 | Key  | Action       |
diff --git a/src/action.rs b/src/action.rs
index 6a5c104..04a1c96 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -1,14 +1,24 @@
-/// Action based on user input
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Action {
+    #[allow(unused)]
+    GoToTopUI,
     #[allow(unused)]
     AppendCharacter(char),
     RemoveCharacter,
+    EnterCommandMode,
+    EnterInsertMode,
+    EnterInsertModeAfter,
+    EnterInsertModeLineStart,
+    EnterInsertModeLineEnd,
+    OpenNewLineBelow,
+    OpenNewLineAbove,
+    DeleteLine,
     Enter,
     CursorLeft,
     CursorRight,
     CursorUp,
     CursorDown,
     Escape,
+    #[allow(unused)]
     Quit,
 }
diff --git a/src/api/auth.rs b/src/api/auth.rs
index 7d4c03a..85cda65 100644
--- a/src/api/auth.rs
+++ b/src/api/auth.rs
@@ -1,4 +1,8 @@
-use crate::api::client::{ApiClient, Endpoint};
+use crate::{
+    Result,
+    api::client::{ApiClient, Endpoint},
+    error::AuthError,
+};
 use keyring::KeyringEntry;
 use serde_json::Value;
 
@@ -7,23 +11,21 @@ pub struct Auth {
 }
 
 impl Auth {
-    pub fn new() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
+    pub fn new() -> Result<Self> {
         let crate_id = "vimstoat";
         let token_entry = KeyringEntry::try_new(crate_id)?;
         Ok(Self { token_entry })
     }
 
-    pub async fn store_token(&self, token: &str) -> Result<(), String> {
-        self.token_entry.set_secret(token).await.map_err(|e| {
-            format!(
-                "{}\n\nUnderlying Details:\n{:?}\n\n💡 Hint: If you are on a minimal Linux install, you likely need to install a Secret Service provider (e.g., `sudo pacman -S gnome-keyring`).",
-                e, e
-            )
-        })
+    pub async fn store_token(&self, token: &str) -> Result<()> {
+        self.token_entry
+            .set_secret(token)
+            .await
+            .map_err(|e| e.into())
     }
 
-    pub async fn validate_token(&self, token: &str) -> Result<ApiClient, String> {
-        let client = ApiClient::new(token.to_string());
+    pub async fn validate_token(&self, token: &str, base_url: Option<String>) -> Result<ApiClient> {
+        let client = ApiClient::new(token.to_string(), base_url);
 
         client
             .get::<Value>(Endpoint::CurrentUser)
@@ -32,9 +34,14 @@ impl Auth {
             .map_err(|e| {
                 let err_msg = e.to_string();
                 if err_msg.contains("401") {
-                    "Invalid token. Please check your session token and try again.".to_string()
+                    AuthError::InvalidToken(
+                        "Please check your session token and try again.".to_string(),
+                    )
+                    .into()
+                } else if err_msg.contains("API GET request") {
+                    AuthError::RequestError(err_msg).into()
                 } else {
-                    err_msg
+                    AuthError::ServerConnectionError.into()
                 }
             })
     }
diff --git a/src/api/channel.rs b/src/api/channel.rs
new file mode 100644
index 0000000..4ca680c
--- /dev/null
+++ b/src/api/channel.rs
@@ -0,0 +1,51 @@
+use crate::{
+    Result,
+    api::client::{ApiClient, Endpoint},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MessageHistoryQuery {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub before: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub after: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sort: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nearby: Option<String>,
+}
+
+pub async fn fetch_message_history(
+    api_client: &ApiClient,
+    channel_id: &str,
+    query: Option<&MessageHistoryQuery>,
+) -> Result<Vec<serde_json::Value>> {
+    let mut path = format!("/channels/{}/messages", channel_id);
+    if let Some(q) = query {
+        let mut params = Vec::new();
+        if let Some(limit) = q.limit {
+            params.push(format!("limit={}", limit));
+        }
+        if let Some(before) = &q.before {
+            params.push(format!("before={}", before));
+        }
+        if let Some(after) = &q.after {
+            params.push(format!("after={}", after));
+        }
+        if let Some(sort) = &q.sort {
+            params.push(format!("sort={}", sort));
+        }
+        if let Some(nearby) = &q.nearby {
+            params.push(format!("nearby={}", nearby));
+        }
+        if !params.is_empty() {
+            path.push('?');
+            path.push_str(&params.join("&"));
+        }
+    }
+
+    api_client.get(Endpoint::Custom(path)).await
+}
diff --git a/src/api/client.rs b/src/api/client.rs
index adaa6b9..ae28e27 100644
--- a/src/api/client.rs
+++ b/src/api/client.rs
@@ -2,9 +2,10 @@ use anyhow::{Result, anyhow};
 use reqwest::Client;
 use serde::de::DeserializeOwned;
 
-const BASE_URL: &str = "https://api.stoat.chat";
+use crate::api::API_BASE_URL;
 
 #[derive(Debug)]
+#[allow(unused)]
 pub enum Endpoint {
     Config,
     CurrentUser,
@@ -14,6 +15,7 @@ pub enum Endpoint {
     Channel(String),
     MessageHistory(String),
     SendMessage(String),
+    Custom(String),
 }
 
 impl Endpoint {
@@ -27,27 +29,31 @@ impl Endpoint {
             Self::Channel(id) => format!("/channels/{}", id),
             Self::MessageHistory(id) => format!("/channels/{}/messages", id),
             Self::SendMessage(id) => format!("/channels/{}/messages", id),
+            Self::Custom(path) => path.clone(),
         }
     }
 }
 
+#[derive(Debug, Clone)]
 pub struct ApiClient {
     client: Client,
     token: String,
+    base_url: String,
 }
 
 impl ApiClient {
-    pub fn new(token: String) -> Self {
+    pub fn new(token: String, base_url: Option<String>) -> Self {
         Self {
             client: Client::new(),
             token,
+            base_url: base_url.unwrap_or(API_BASE_URL.to_string()),
         }
     }
 
     /// Makes a GET request to the specified endpoint and deserializes the JSON response into `T`.
     /// The `endpoint` should start with a slash, e.g., `/users/@me`.
     pub async fn get<T: DeserializeOwned>(&self, endpoint: Endpoint) -> Result<T> {
-        let url = format!("{}{}", BASE_URL, endpoint.path());
+        let url = format!("{}{}", self.base_url, endpoint.path());
 
         let response = self
             .client
@@ -70,6 +76,40 @@ impl ApiClient {
             ))
         }
     }
+
+    pub async fn post<T: DeserializeOwned, B: serde::Serialize>(
+        &self,
+        endpoint: Endpoint,
+        body: &B,
+    ) -> Result<T> {
+        let url = format!("{}{}", self.base_url, endpoint.path());
+
+        let response = self
+            .client
+            .post(&url)
+            .header("X-Session-Token", &self.token)
+            .json(body)
+            .send()
+            .await?;
+
+        if response.status().is_success() {
+            let data = response.json::<T>().await?;
+            Ok(data)
+        } else {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            Err(anyhow!(
+                "API POST request to {:?} failed: {} - {}",
+                endpoint,
+                status,
+                text
+            ))
+        }
+    }
+
+    pub fn clone_token(&self) -> String {
+        self.token.clone()
+    }
 }
 
 #[cfg(test)]
@@ -80,7 +120,7 @@ mod tests {
     #[tokio::test]
     async fn test_get_config() {
         // Token doesn't matter for the root config endpoint, but we provide a dummy one
-        let client = ApiClient::new("dummy_token".to_string());
+        let client = ApiClient::new("dummy_token".to_string(), None);
 
         let result = client.get::<Value>(Endpoint::Config).await;
         assert!(result.is_ok(), "Failed to get config: {:?}", result.err());
diff --git a/src/api/dm.rs b/src/api/dm.rs
new file mode 100644
index 0000000..5fdc395
--- /dev/null
+++ b/src/api/dm.rs
@@ -0,0 +1,157 @@
+use crate::{
+    Result,
+    api::client::{ApiClient, Endpoint},
+    models::{DirectMessageChannel, User},
+};
+
+pub async fn fetch_dms(
+    api_client: &ApiClient,
+    known_users: &std::collections::HashMap<String, User>,
+) -> Result<(Vec<DirectMessageChannel>, Vec<User>)> {
+    let dms_json: Vec<serde_json::Value> = api_client.get(Endpoint::Dms).await?;
+
+    let my_user_id = match api_client
+        .get::<serde_json::Value>(Endpoint::CurrentUser)
+        .await
+    {
+        Ok(user_val) => user_val
+            .get("_id")
+            .or_else(|| user_val.get("id"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string()),
+        Err(_) => None,
+    };
+
+    let mut dm_channels = Vec::new();
+    let mut new_users = Vec::new();
+
+    for channel in dms_json {
+        let id = channel
+            .get("_id")
+            .or_else(|| channel.get("id"))
+            .and_then(|v| v.as_str());
+
+        let mut display_name = channel
+            .get("name")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        if display_name.is_none() {
+            let channel_type = channel
+                .get("channel_type")
+                .and_then(|v| v.as_str())
+                .unwrap_or_default();
+
+            if channel_type == "SavedMessages" {
+                display_name = Some("Saved Messages".to_string());
+            } else {
+                let mut user_ids: Vec<String> = Vec::new();
+
+                if let Some(recipients_arr) = channel.get("recipients").and_then(|v| v.as_array()) {
+                    for v in recipients_arr {
+                        let id_opt = v.as_str().or_else(|| {
+                            v.get("_id")
+                                .or_else(|| v.get("id"))
+                                .and_then(|i| i.as_str())
+                        });
+                        if let Some(id_str) = id_opt
+                            && !user_ids.contains(&id_str.to_string())
+                        {
+                            user_ids.push(id_str.to_string());
+                        }
+                    }
+                }
+
+                for key in &["recipient", "user", "user_id"] {
+                    let id_opt = channel.get(*key).and_then(|v| {
+                        v.as_str().or_else(|| {
+                            v.get("_id")
+                                .or_else(|| v.get("id"))
+                                .and_then(|i| i.as_str())
+                        })
+                    });
+                    if let Some(id_str) = id_opt
+                        && !user_ids.contains(&id_str.to_string())
+                    {
+                        user_ids.push(id_str.to_string());
+                    }
+                }
+
+                if user_ids.len() == 1 {
+                    let target_id = &user_ids[0];
+                    if Some(target_id) == my_user_id.as_ref() {
+                        display_name = Some("Saved Messages".to_string());
+                    } else {
+                        if let Some(user) = known_users.get(target_id) {
+                            display_name = Some(user.username.clone());
+                        }
+
+                        if display_name.is_none()
+                            && let Ok(user_val) = api_client
+                                .get::<serde_json::Value>(Endpoint::User(target_id.clone()))
+                                .await
+                            && let Some(username) =
+                                user_val.get("username").and_then(|v| v.as_str())
+                        {
+                            display_name = Some(username.to_string());
+                            new_users.push(User {
+                                id: target_id.clone(),
+                                username: username.to_string(),
+                            });
+                        }
+                    }
+                    if display_name.is_none() {
+                        display_name = Some(target_id.clone());
+                    }
+                } else if user_ids.len() == 2 {
+                    let other_id = if let Some(my_id) = &my_user_id {
+                        user_ids.iter().find(|id| *id != my_id).cloned()
+                    } else {
+                        user_ids.first().cloned()
+                    };
+
+                    if let Some(target_id) = other_id {
+                        if let Some(user) = known_users.get(&target_id) {
+                            display_name = Some(user.username.clone());
+                        }
+
+                        if display_name.is_none()
+                            && let Ok(user_val) = api_client
+                                .get::<serde_json::Value>(Endpoint::User(target_id.clone()))
+                                .await
+                            && let Some(username) =
+                                user_val.get("username").and_then(|v| v.as_str())
+                        {
+                            display_name = Some(username.to_string());
+                            new_users.push(User {
+                                id: target_id.clone(),
+                                username: username.to_string(),
+                            });
+                        }
+                        if display_name.is_none() {
+                            display_name = Some(target_id);
+                        }
+                    }
+                } else if user_ids.len() >= 3 {
+                    display_name = Some(format!("Group DM ({} members)", user_ids.len()));
+                }
+            }
+        }
+
+        let name = display_name.unwrap_or_else(|| {
+            id.map(|s| format!("DM ({s})"))
+                .unwrap_or_else(|| "Direct Message".to_string())
+        });
+
+        if let Some(id_str) = id {
+            dm_channels.push(DirectMessageChannel {
+                id: id_str.to_string(),
+                name,
+                has_unread: false,
+                last_message_preview: None,
+            });
+        }
+    }
+
+    Ok((dm_channels, new_users))
+}
diff --git a/src/api/events.rs b/src/api/events.rs
new file mode 100644
index 0000000..d468bef
--- /dev/null
+++ b/src/api/events.rs
@@ -0,0 +1,179 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+#[allow(unused)]
+pub enum ClientEvent {
+    Authenticate { token: String },
+    BeginTyping { channel: String },
+    EndTyping { channel: String },
+    Ping { data: u64 },
+    Subscribe { server_id: String },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[allow(unused)]
+pub struct ServerMemberId {
+    pub server: String,
+    pub user: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "event_type")]
+#[allow(unused)]
+pub enum AuthEvent {
+    DeleteSession {
+        user_id: String,
+        session_id: String,
+    },
+    DeleteAllSessions {
+        user_id: String,
+        exclude_session_id: Option<String>,
+    },
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "type")]
+#[allow(unused)]
+pub enum ServerEvent {
+    Error {
+        error: String,
+    },
+    Authenticated,
+    Logout,
+    Bulk {
+        v: Vec<ServerEvent>,
+    },
+    Pong {
+        data: Value,
+    },
+    Ready {
+        users: Option<Vec<Value>>,
+        servers: Option<Vec<Value>>,
+        channels: Option<Vec<Value>>,
+        members: Option<Vec<Value>>,
+        emojis: Option<Vec<Value>>,
+        user_settings: Option<Vec<Value>>,
+        channel_unreads: Option<Vec<Value>>,
+        policy_changes: Option<Vec<Value>>,
+    },
+    Message(Value),
+    MessageUpdate {
+        id: String,
+        channel: String,
+        data: Value,
+    },
+    MessageAppend {
+        id: String,
+        channel: String,
+        append: Value,
+    },
+    MessageDelete {
+        id: String,
+        channel: String,
+    },
+    MessageReact {
+        id: String,
+        channel_id: String,
+        user_id: String,
+        emoji_id: String,
+    },
+    MessageUnreact {
+        id: String,
+        channel_id: String,
+        user_id: String,
+        emoji_id: String,
+    },
+    MessageRemoveReaction {
+        id: String,
+        channel_id: String,
+        emoji_id: String,
+    },
+    ChannelCreate(Value),
+    ChannelUpdate {
+        id: String,
+        data: Value,
+        clear: Option<Vec<String>>,
+    },
+    ChannelDelete {
+        id: String,
+    },
+    ChannelGroupJoin {
+        id: String,
+        user: String,
+    },
+    ChannelGroupLeave {
+        id: String,
+        user: String,
+    },
+    ChannelStartTyping {
+        id: String,
+        user: String,
+    },
+    ChannelStopTyping {
+        id: String,
+        user: String,
+    },
+    ChannelAck {
+        id: String,
+        user: String,
+        message_id: String,
+    },
+    ServerCreate(Value),
+    ServerUpdate {
+        id: String,
+        data: Value,
+        clear: Option<Vec<String>>,
+    },
+    ServerDelete {
+        id: String,
+    },
+    ServerMemberUpdate {
+        id: ServerMemberId,
+        data: Value,
+        clear: Option<Vec<String>>,
+    },
+    ServerMemberJoin {
+        id: String,
+        user: String,
+        member: Value,
+    },
+    ServerMemberLeave {
+        id: String,
+        user: String,
+    },
+    ServerRoleUpdate {
+        id: String,
+        role_id: String,
+        data: Value,
+        clear: Option<Vec<String>>,
+    },
+    ServerRoleDelete {
+        id: String,
+        role_id: String,
+    },
+    UserUpdate {
+        id: String,
+        data: Value,
+        clear: Option<Vec<String>>,
+    },
+    UserRelationship {
+        id: String,
+        user: Value,
+        status: String,
+    },
+    UserPlatformWipe {
+        user_id: String,
+        flags: Value,
+    },
+    EmojiCreate(Value),
+    EmojiUpdate {
+        id: String,
+        data: Value,
+    },
+    EmojiDelete {
+        id: String,
+    },
+    Auth(AuthEvent),
+}
diff --git a/src/api/mod.rs b/src/api/mod.rs
index 9ee5abf..39abba2 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -1,2 +1,9 @@
 pub mod auth;
+pub mod channel;
 pub mod client;
+pub mod dm;
+pub mod events;
+pub mod ws;
+
+pub const API_BASE_URL: &str = "https://api.stoat.chat";
+pub const WS_BASE_URL: &str = "wss://events.stoat.chat";
diff --git a/src/api/ws.rs b/src/api/ws.rs
new file mode 100644
index 0000000..f50a5ce
--- /dev/null
+++ b/src/api/ws.rs
@@ -0,0 +1,175 @@
+use crate::{
+    Result,
+    api::{
+        WS_BASE_URL,
+        events::{ClientEvent, ServerEvent},
+    },
+    models::Server,
+};
+use futures_util::{SinkExt, StreamExt};
+use log::{error, info};
+use serde_json::Value;
+use tokio::sync::mpsc;
+use tokio_tungstenite::{connect_async, tungstenite::protocol::Message as WsMessage};
+
+const OUTGOING_BUFFER_SIZE: usize = 32;
+const INCOMING_BUFFER_SIZE: usize = 100;
+
+pub struct WsClient {
+    tx_outgoing: mpsc::Sender<ClientEvent>,
+}
+
+impl WsClient {
+    pub async fn connect(base_url: Option<String>) -> Result<(Self, mpsc::Receiver<ServerEvent>)> {
+        let url = base_url.unwrap_or_else(|| WS_BASE_URL.to_string());
+        let (ws_stream, _) = connect_async(&url).await?;
+        let (mut write, mut read) = ws_stream.split();
+
+        let (tx_outgoing, mut rx_outgoing) = mpsc::channel::<ClientEvent>(OUTGOING_BUFFER_SIZE);
+        let (tx_incoming, rx_incoming) = mpsc::channel::<ServerEvent>(INCOMING_BUFFER_SIZE);
+
+        tokio::spawn(async move {
+            while let Some(msg) = read.next().await {
+                match msg {
+                    Ok(WsMessage::Text(text)) => match serde_json::from_str::<ServerEvent>(&text) {
+                        Ok(event) => {
+                            Self::dispatch_event(event, &tx_incoming).await;
+                        }
+                        Err(e) => {
+                            error!("Error deserializing ServerEvent: {e}\nRaw data: {text}");
+                            break;
+                        }
+                    },
+                    Ok(WsMessage::Close(_)) => {
+                        info!("WS Connection closed by server.");
+                        break;
+                    }
+                    Err(e) => {
+                        error!("WS Error: {e}");
+                        break;
+                    }
+                    _ => {}
+                }
+            }
+        });
+
+        tokio::spawn(async move {
+            while let Some(event) = rx_outgoing.recv().await {
+                if let Ok(json) = serde_json::to_string(&event)
+                    && let Err(e) = write.send(WsMessage::Text(json.into())).await
+                {
+                    error!("Error sending WsMessage: {e}");
+                    break;
+                }
+            }
+        });
+
+        Ok((Self { tx_outgoing }, rx_incoming))
+    }
+
+    pub async fn send_event(&self, event: ClientEvent) -> Result<()> {
+        self.tx_outgoing.send(event).await.map_err(|e| e.into())
+    }
+
+    pub fn clone_sender(&self) -> mpsc::Sender<ClientEvent> {
+        self.tx_outgoing.clone()
+    }
+
+    pub async fn dispatch_event(event: ServerEvent, tx: &mpsc::Sender<ServerEvent>) {
+        if let ServerEvent::Bulk { v } = event {
+            for sub_event in v {
+                Box::pin(Self::dispatch_event(sub_event, tx)).await;
+            }
+        } else {
+            tx.send(event).await.ok();
+        }
+    }
+}
+
+pub struct EventHandler<'a> {
+    servers: &'a mut Vec<Server>,
+}
+
+impl<'a> EventHandler<'a> {
+    pub fn new(servers: &'a mut Vec<Server>) -> Self {
+        Self { servers }
+    }
+
+    pub fn handle_event(&mut self, event: &ServerEvent) {
+        #[allow(clippy::single_match)]
+        match event {
+            ServerEvent::Ready { servers, .. } => {
+                self.handle_ready(servers.as_deref());
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_ready(&mut self, servers: Option<&[Value]>) {
+        if let Some(servers) = servers {
+            for server_val in servers {
+                self.handle_server(server_val);
+            }
+        }
+    }
+
+    fn handle_server(&mut self, server_val: &Value) {
+        let id = server_val
+            .get("_id")
+            .or_else(|| server_val.get("id"))
+            .and_then(|v| v.as_str());
+        let name = server_val.get("name").and_then(|v| v.as_str());
+        let description = server_val
+            .get("description")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        if let (Some(id_str), Some(name_str)) = (id, name) {
+            let server = Server {
+                id: id_str.to_string(),
+                name: name_str.to_string(),
+                description,
+            };
+            self.servers.retain(|s| s.id != id_str);
+            self.servers.push(server);
+            info!("Stored server in memory: {id_str} => {name_str}");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_handle_ready_event_servers_in_memory() {
+        let mut servers = Vec::new();
+
+        let server_id = "01KXCTGX37FXG9CASWC35R3S21";
+        let server_name = "vimstoat";
+
+        let ready_event = ServerEvent::Ready {
+            users: None,
+            servers: Some(vec![json!({
+                "_id": server_id,
+                "name": server_name,
+                "description": null
+            })]),
+            channels: None,
+            members: None,
+            emojis: None,
+            user_settings: None,
+            channel_unreads: None,
+            policy_changes: None,
+        };
+
+        let mut handler = EventHandler::new(&mut servers);
+        handler.handle_event(&ready_event);
+
+        assert_eq!(servers.len(), 1, "Server should be stored in memory");
+        assert_eq!(servers[0].id, server_id);
+        assert_eq!(servers[0].name, server_name);
+        assert_eq!(servers[0].description, None);
+    }
+}
diff --git a/src/app.rs b/src/app.rs
index ea1741f..293bd78 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,106 +1,318 @@
-use ratatui::crossterm::event::{KeyCode, KeyEvent};
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use crate::action::Action;
-use crate::api::auth::Auth;
-use crate::api::client::ApiClient;
-use crate::input::InputState;
-use crate::{Result, cache::CacheStore};
+use log::{debug, error, info, warn};
+use ratatui::crossterm::event::KeyEvent;
+use tokio::sync::Mutex;
+use tokio::sync::mpsc::{self, Receiver, Sender};
+use tokio::time;
+
+use crate::{
+    Result,
+    api::{
+        API_BASE_URL,
+        auth::Auth,
+        client::ApiClient,
+        events::{ClientEvent, ServerEvent},
+        ws::WsClient,
+    },
+    cache::CacheStore,
+    input::{InputMode, InputState},
+    models::{DirectMessageChannel, Server},
+};
+
+pub enum AppEvent {
+    DmsLoaded(Vec<DirectMessageChannel>, Vec<crate::models::User>),
+    DmMessagesLoaded(Vec<crate::models::Message>, Vec<crate::models::User>),
+    NewMessage {
+        channel_id: String,
+        message: crate::models::Message,
+        new_user: Option<crate::models::User>,
+    },
+    MessageUpdated {
+        channel_id: String,
+        message_id: String,
+        content: String,
+    },
+    MessageDeleted {
+        channel_id: String,
+        message_id: String,
+    },
+}
 
 pub enum AppState {
     InputToken,
     ValidatingToken,
     LoggedIn,
-    Error(String),
+    DmList,
+    Dm,
+    Error(anyhow::Error),
+}
+
+#[derive(Default)]
+pub struct AppStore {
+    pub servers: Vec<Server>,
+    pub dm_channels: Vec<DirectMessageChannel>,
+    pub current_dm_messages: Vec<crate::models::Message>,
+    pub users: std::collections::HashMap<String, crate::models::User>,
 }
 
 pub struct App {
     pub state: AppState,
     pub input_text: String,
+    pub input_cursor: usize,
+    pub yank_buffer: Option<String>,
+    pub command_text: String,
     pub auth: Auth,
     pub should_quit: bool,
     pub input_state: InputState,
-    pub client: ApiClient,
-    #[allow(unused)]
-    pub cache: CacheStore,
+    pub api_base_url: String,
+    pub api_client: ApiClient,
+    pub ws_client: WsClient,
+    pub ws_rx: Receiver<ServerEvent>,
+    pub cache: Arc<Mutex<CacheStore>>,
+    pub store: AppStore,
+    pub selected_index: usize,
+    pub selected_dm_index: usize,
+    pub is_loading_dms: bool,
+    pub is_loading_messages: bool,
+    pub app_tx: Sender<AppEvent>,
+    pub app_rx: Receiver<AppEvent>,
 }
 
 impl App {
-    pub async fn new() -> Result<Self> {
+    pub async fn new(api_base_url: Option<String>, ws_base_url: Option<String>) -> Result<Self> {
         let auth = Auth::new().map_err(|e| anyhow::anyhow!(e))?;
 
-        let mut client = ApiClient::new(String::new());
+        let mut api_client = ApiClient::new(String::new(), api_base_url.clone());
 
         let state = if let Ok(token) = auth.token_entry.get_secret().await {
-            match auth.validate_token(&token).await {
+            match auth.validate_token(&token, api_base_url.clone()).await {
                 Ok(authenticated_client) => {
-                    client = authenticated_client;
+                    api_client = authenticated_client;
                     AppState::LoggedIn
                 }
-                Err(e) => AppState::Error(format!("Stored token is invalid: {}", e)),
+                Err(e) => AppState::Error(e),
             }
         } else {
             AppState::InputToken
         };
 
-        let cache = CacheStore::new()?;
+        let (ws_client, ws_rx) = WsClient::connect(ws_base_url).await?;
+
+        let cache = Arc::new(Mutex::new(CacheStore::new()?));
+        let (app_tx, app_rx) = mpsc::channel::<AppEvent>(32);
 
         Ok(Self {
             state,
             input_text: String::new(),
+            input_cursor: 0,
+            yank_buffer: None,
+            command_text: String::new(),
             auth,
             should_quit: false,
-            client,
-            cache,
+            api_base_url: api_base_url.unwrap_or(API_BASE_URL.to_string()),
+            api_client,
+            ws_client,
+            ws_rx,
+            cache: cache.clone(),
+            store: AppStore {
+                users: cache.lock().await.get_all_users(),
+                ..Default::default()
+            },
+            selected_index: 0,
+            selected_dm_index: 0,
+            is_loading_dms: false,
+            is_loading_messages: false,
+            app_tx,
+            app_rx,
             input_state: InputState::default(),
         })
     }
 
-    pub async fn handle_key_event(&mut self, key: KeyEvent) -> Result<()> {
-        match self.state {
-            AppState::InputToken => match key.code {
-                KeyCode::Enter => {
-                    if !self.input_text.is_empty() {
-                        self.state = AppState::ValidatingToken;
-                        match self.auth.validate_token(&self.input_text).await {
-                            Ok(client) => match self.auth.store_token(&self.input_text).await {
-                                Ok(_) => {
-                                    self.client = client;
-                                    self.state = AppState::LoggedIn;
-                                }
-                                Err(detailed_err) => {
-                                    self.state = AppState::Error(detailed_err);
-                                }
-                            },
-                            Err(e) => {
-                                self.state = AppState::Error(e);
-                            }
-                        }
+    pub fn handle_app_event(&mut self, event: AppEvent) {
+        match event {
+            AppEvent::DmsLoaded(dms, new_users) => {
+                for user in new_users {
+                    self.store.users.insert(user.id.clone(), user);
+                }
+                self.store.dm_channels = dms;
+                self.is_loading_dms = false;
+            }
+            AppEvent::DmMessagesLoaded(messages, new_users) => {
+                for user in new_users {
+                    self.store.users.insert(user.id.clone(), user);
+                }
+                self.store.current_dm_messages = messages;
+                self.is_loading_messages = false;
+            }
+            AppEvent::NewMessage {
+                channel_id,
+                message,
+                new_user,
+            } => {
+                if let Some(user) = new_user {
+                    self.store.users.insert(user.id.clone(), user);
+                }
+
+                let is_active_channel = matches!(self.state, AppState::Dm)
+                    && self
+                        .store
+                        .dm_channels
+                        .get(self.selected_dm_index)
+                        .map(|c| &c.id)
+                        == Some(&channel_id);
+
+                if is_active_channel {
+                    self.store.current_dm_messages.insert(0, message.clone()); // newest is at 0 (rev order in UI)
+                }
+
+                if let Some(channel) = self
+                    .store
+                    .dm_channels
+                    .iter_mut()
+                    .find(|c| c.id == channel_id)
+                {
+                    if !is_active_channel {
+                        channel.has_unread = true;
                     }
+                    channel.last_message_preview = Some(message.content);
                 }
-                KeyCode::Char(c) => {
-                    self.input_text.push(c);
+            }
+            AppEvent::MessageUpdated {
+                channel_id,
+                message_id,
+                content,
+            } => {
+                let is_active_channel = matches!(self.state, AppState::Dm)
+                    && self
+                        .store
+                        .dm_channels
+                        .get(self.selected_dm_index)
+                        .map(|c| &c.id)
+                        == Some(&channel_id);
+
+                if is_active_channel
+                    && let Some(msg) = self
+                        .store
+                        .current_dm_messages
+                        .iter_mut()
+                        .find(|m| m.id == message_id)
+                {
+                    msg.content = content;
+                }
+            }
+            AppEvent::MessageDeleted {
+                channel_id,
+                message_id,
+            } => {
+                let is_active_channel = matches!(self.state, AppState::Dm)
+                    && self
+                        .store
+                        .dm_channels
+                        .get(self.selected_dm_index)
+                        .map(|c| &c.id)
+                        == Some(&channel_id);
+
+                if is_active_channel {
+                    self.store
+                        .current_dm_messages
+                        .retain(|m| m.id != message_id);
                 }
-                KeyCode::Backspace => {
-                    self.input_text.pop();
+            }
+        }
+    }
+
+    pub fn go_back_or_quit(&mut self) {
+        match self.state {
+            AppState::DmList => self.state = AppState::LoggedIn,
+            AppState::Dm => {
+                self.state = AppState::DmList;
+                self.set_input_mode(InputMode::UI);
+            }
+            _ => self.should_quit = true,
+        }
+    }
+
+    pub fn set_input_mode(&mut self, new_mode: InputMode) {
+        self.input_state.change_input_mode(new_mode);
+        let style = match new_mode {
+            InputMode::Insert | InputMode::Command => {
+                ratatui::crossterm::cursor::SetCursorStyle::BlinkingBar
+            }
+            _ => ratatui::crossterm::cursor::SetCursorStyle::BlinkingBlock,
+        };
+        let _ = ratatui::crossterm::execute!(std::io::stdout(), style);
+    }
+
+    pub async fn handle_key_event(&mut self, key: KeyEvent) -> Result<()> {
+        if matches!(self.input_state.input_mode, InputMode::Command) {
+            crate::handlers::command::handle(self, key);
+            return Ok(());
+        }
+
+        match self.state {
+            AppState::InputToken => crate::handlers::input_token::handle(self, key).await,
+            AppState::ValidatingToken => {}
+            AppState::LoggedIn => crate::handlers::logged_in::handle(self, key),
+            AppState::DmList => crate::handlers::dm_list::handle(self, key),
+            AppState::Dm => crate::handlers::dm::handle(self, key),
+            AppState::Error(_) => crate::handlers::error::handle(self, key),
+        }
+        Ok(())
+    }
+
+    pub async fn authenticate_ws(&mut self, token: &str) -> Result<()> {
+        self.ws_client
+            .send_event(ClientEvent::Authenticate {
+                token: token.into(),
+            })
+            .await?;
+
+        let mut is_authenticated = false;
+        while let Some(event) = self.ws_rx.recv().await {
+            match event {
+                ServerEvent::Authenticated => {
+                    info!("Successfully authenticated!");
+                    is_authenticated = true;
+                    break;
                 }
-                KeyCode::Esc => {
-                    self.should_quit = true;
+                ServerEvent::Error { error } => {
+                    error!("Error authenticating: {error}");
+                    return Err(anyhow::anyhow!("WebSocket authentication failed: {error}"));
                 }
                 _ => {}
-            },
-            AppState::ValidatingToken => {}
-            AppState::LoggedIn => {
-                let action = self.input_state.process_key_event(key);
-                if let Some(Action::Quit) = action {
-                    self.should_quit = true;
-                };
             }
-            AppState::Error(_) => {
-                if matches!(key.code, KeyCode::Char(_) | KeyCode::Esc | KeyCode::Enter) {
-                    self.state = AppState::InputToken;
+        }
+
+        if is_authenticated {
+            let tx_ping = self.ws_client.clone_sender();
+
+            tokio::spawn(async move {
+                let mut interval = time::interval(Duration::from_secs(20));
+
+                loop {
+                    interval.tick().await;
+
+                    let timestamp = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap()
+                        .as_millis() as u64;
+
+                    if tx_ping
+                        .send(ClientEvent::Ping { data: timestamp })
+                        .await
+                        .is_err()
+                    {
+                        warn!("Stopped pinging: channel closed.");
+                        break;
+                    }
                 }
-            }
+            });
+
+            debug!("Started pinging every 20s.");
         }
+
         Ok(())
     }
 }
diff --git a/src/cache.rs b/src/cache.rs
index d001c36..3a77a92 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -78,14 +78,14 @@ impl CacheStore {
         let db = if path.exists() {
             PickleDb::load(
                 &path,
-                pickledb::PickleDbDumpPolicy::AutoDump,
+                pickledb::PickleDbDumpPolicy::DumpUponRequest,
                 pickledb::SerializationMethod::Bin,
             )
             .map_err(CacheError::DbError)?
         } else {
             PickleDb::new(
                 &path,
-                pickledb::PickleDbDumpPolicy::AutoDump,
+                pickledb::PickleDbDumpPolicy::DumpUponRequest,
                 pickledb::SerializationMethod::Bin,
             )
         };
@@ -93,6 +93,35 @@ impl CacheStore {
         Ok(Self { db, path })
     }
 
+    #[cfg(test)]
+    pub fn new_temporary(dir: &std::path::Path) -> Result<Self> {
+        let path = dir.join(DB_FILE);
+        let db = PickleDb::new(
+            &path,
+            pickledb::PickleDbDumpPolicy::DumpUponRequest,
+            pickledb::SerializationMethod::Bin,
+        );
+        Ok(Self { db, path })
+    }
+
+    pub fn dump(&mut self) -> Result<()> {
+        log::info!("Dumping cache to disk...");
+        self.db.dump().map_err(CacheError::DbError)?;
+        Ok(())
+    }
+
+    pub fn get_all_users(&self) -> std::collections::HashMap<String, crate::models::User> {
+        let mut users = std::collections::HashMap::new();
+        for key in self.db.get_all() {
+            if key.starts_with("user:")
+                && let Some(user) = self.db.get::<crate::models::User>(&key)
+            {
+                users.insert(user.id.clone(), user);
+            }
+        }
+        users
+    }
+
     pub fn set<V: Serialize + Debug>(&mut self, id: Id<V>, value: &V) -> Result<()> {
         let key = Self::build_key::<V>(id)?;
 
diff --git a/src/command.rs b/src/command.rs
new file mode 100644
index 0000000..2a35540
--- /dev/null
+++ b/src/command.rs
@@ -0,0 +1,71 @@
+use crate::app::App;
+
+/// Represents commands entered in Vim command mode (e.g. `:q`, `:quit`)
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Command {
+    Quit,
+    QuitAll,
+    Unknown(String),
+}
+
+impl Command {
+    /// Parses a raw command string (without leading colon) into a `Command`.
+    pub fn parse(input: &str) -> Option<Self> {
+        let trimmed = input.trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+
+        let cmd = match trimmed {
+            "q" | "quit" | "q!" => Command::Quit,
+            "qa" | "qa!" | "qall" | "qall!" => Command::QuitAll,
+            other => Command::Unknown(other.to_string()),
+        };
+
+        Some(cmd)
+    }
+
+    pub fn execute(&self, app: &mut App) {
+        match self {
+            Command::Quit => {
+                app.go_back_or_quit();
+            }
+            Command::QuitAll => {
+                app.should_quit = true;
+            }
+            Command::Unknown(cmd_name) => {
+                log::warn!("Unknown command: :{cmd_name}");
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_quit_commands() {
+        assert_eq!(Command::parse("q"), Some(Command::Quit));
+        assert_eq!(Command::parse("quit"), Some(Command::Quit));
+        assert_eq!(Command::parse("q!"), Some(Command::Quit));
+        assert_eq!(Command::parse("  q  "), Some(Command::Quit));
+        assert_eq!(Command::parse("qa"), Some(Command::QuitAll));
+        assert_eq!(Command::parse("qa!"), Some(Command::QuitAll));
+        assert_eq!(Command::parse("qall"), Some(Command::QuitAll));
+    }
+
+    #[test]
+    fn test_parse_unknown_command() {
+        assert_eq!(
+            Command::parse("foo"),
+            Some(Command::Unknown("foo".to_string()))
+        );
+    }
+
+    #[test]
+    fn test_parse_empty() {
+        assert_eq!(Command::parse(""), None);
+        assert_eq!(Command::parse("   "), None);
+    }
+}
diff --git a/src/error.rs b/src/error.rs
index eb5d750..8397af5 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -20,3 +20,24 @@ impl From<pickledb::error::Error> for CacheError {
         CacheError::DbError(value)
     }
 }
+
+#[derive(Error, Debug)]
+pub enum AuthError {
+    #[error("Keyring Error: {0:?}")]
+    KeyringError(keyring::Error),
+
+    #[error("Invalid Token: {0}")]
+    InvalidToken(String),
+
+    #[error("Could not connect to the server. Please check your internet connection.")]
+    ServerConnectionError,
+
+    #[error("Request Error: {0}")]
+    RequestError(String),
+}
+
+impl From<keyring::Error> for AuthError {
+    fn from(value: keyring::Error) -> Self {
+        AuthError::KeyringError(value)
+    }
+}
diff --git a/src/handlers/command.rs b/src/handlers/command.rs
new file mode 100644
index 0000000..d20bb37
--- /dev/null
+++ b/src/handlers/command.rs
@@ -0,0 +1,35 @@
+use ratatui::crossterm::event::KeyEvent;
+
+use crate::{action::Action, app::App, command::Command, input::InputMode};
+
+pub fn handle(app: &mut App, key: KeyEvent) {
+    let action = app.input_state.process_key_event(key);
+    match action {
+        Some(Action::AppendCharacter(c)) => {
+            app.command_text.push(c);
+        }
+        Some(Action::RemoveCharacter) => {
+            app.command_text.pop();
+        }
+        Some(Action::Escape) => {
+            app.command_text.clear();
+            if matches!(app.state, crate::app::AppState::Dm) {
+                app.set_input_mode(InputMode::Normal);
+            } else {
+                app.set_input_mode(InputMode::UI);
+            }
+        }
+        Some(Action::Enter) => {
+            if let Some(cmd) = Command::parse(&app.command_text) {
+                cmd.execute(app);
+            }
+            app.command_text.clear();
+            if matches!(app.state, crate::app::AppState::Dm) {
+                app.set_input_mode(InputMode::Normal);
+            } else {
+                app.set_input_mode(InputMode::UI);
+            }
+        }
+        _ => {}
+    }
+}
diff --git a/src/handlers/dm.rs b/src/handlers/dm.rs
new file mode 100644
index 0000000..bd0686f
--- /dev/null
+++ b/src/handlers/dm.rs
@@ -0,0 +1,285 @@
+use ratatui::crossterm::event::KeyEvent;
+
+use crate::{action::Action, app::App, input::InputMode};
+
+pub fn handle(app: &mut App, key: KeyEvent) {
+    let action = app.input_state.process_key_event(key);
+    match action {
+        Some(Action::CursorLeft) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            if app.input_cursor > 0 && chars.get(app.input_cursor - 1) != Some(&'\n') {
+                app.input_cursor -= 1;
+            }
+        }
+        Some(Action::CursorRight) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            let max_for_line = {
+                let mut end = app.input_cursor;
+                while end < chars.len() && chars[end] != '\n' {
+                    end += 1;
+                }
+                if matches!(app.input_state.input_mode, InputMode::Insert) {
+                    end
+                } else if end > 0 && chars.get(end - 1) != Some(&'\n') {
+                    end - 1
+                } else {
+                    end
+                }
+            };
+            if app.input_cursor < max_for_line {
+                app.input_cursor += 1;
+            }
+        }
+        Some(Action::CursorUp) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            let mut line_start = 0;
+            for i in (0..app.input_cursor).rev() {
+                if chars.get(i) == Some(&'\n') {
+                    line_start = i + 1;
+                    break;
+                }
+            }
+            if line_start > 0 {
+                let col = app.input_cursor - line_start;
+                let mut prev_line_start = 0;
+                for i in (0..line_start - 1).rev() {
+                    if chars.get(i) == Some(&'\n') {
+                        prev_line_start = i + 1;
+                        break;
+                    }
+                }
+                let prev_line_len = (line_start - 1) - prev_line_start;
+
+                let is_normal = matches!(app.input_state.input_mode, InputMode::Normal);
+                let max_col = if is_normal && prev_line_len > 0 {
+                    prev_line_len - 1
+                } else {
+                    prev_line_len
+                };
+
+                app.input_cursor = prev_line_start + col.min(max_col);
+            }
+        }
+        Some(Action::CursorDown) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            let mut line_start = 0;
+            for i in (0..app.input_cursor).rev() {
+                if chars.get(i) == Some(&'\n') {
+                    line_start = i + 1;
+                    break;
+                }
+            }
+            let col = app.input_cursor - line_start;
+
+            let mut next_line_start = None;
+            for (i, c) in chars.iter().enumerate().skip(app.input_cursor) {
+                if *c == '\n' {
+                    next_line_start = Some(i + 1);
+                    break;
+                }
+            }
+            if let Some(start) = next_line_start {
+                let mut next_line_len = 0;
+                for c in chars.iter().skip(start) {
+                    if *c == '\n' {
+                        break;
+                    }
+                    next_line_len += 1;
+                }
+                let is_normal = matches!(app.input_state.input_mode, InputMode::Normal);
+                let max_col = if is_normal && next_line_len > 0 {
+                    next_line_len - 1
+                } else {
+                    next_line_len
+                };
+                app.input_cursor = start + col.min(max_col);
+            }
+        }
+        Some(Action::Quit) => app.go_back_or_quit(),
+        Some(Action::EnterCommandMode) => {
+            app.command_text.clear();
+            app.set_input_mode(InputMode::Command);
+        }
+        Some(Action::EnterInsertMode) => {
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::EnterInsertModeAfter) => {
+            if app.input_cursor < app.input_text.chars().count() {
+                app.input_cursor += 1;
+            }
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::EnterInsertModeLineStart) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            let mut line_start = 0;
+            for i in (0..app.input_cursor).rev() {
+                if chars.get(i) == Some(&'\n') {
+                    line_start = i + 1;
+                    break;
+                }
+            }
+            app.input_cursor = line_start;
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::EnterInsertModeLineEnd) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            let mut line_end = chars.len();
+            for (i, c) in chars.iter().enumerate().skip(app.input_cursor) {
+                if *c == '\n' {
+                    line_end = i;
+                    break;
+                }
+            }
+            app.input_cursor = line_end;
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::OpenNewLineBelow) => {
+            let mut chars: Vec<char> = app.input_text.chars().collect();
+            let mut insert_idx = chars.len();
+            for (i, c) in chars.iter().enumerate().skip(app.input_cursor) {
+                if *c == '\n' {
+                    insert_idx = i;
+                    break;
+                }
+            }
+            chars.insert(insert_idx, '\n');
+            app.input_text = chars.into_iter().collect();
+            app.input_cursor = insert_idx + 1;
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::OpenNewLineAbove) => {
+            let mut chars: Vec<char> = app.input_text.chars().collect();
+            let mut insert_idx = 0;
+            for i in (0..app.input_cursor).rev() {
+                if chars.get(i) == Some(&'\n') {
+                    insert_idx = i + 1;
+                    break;
+                }
+            }
+            chars.insert(insert_idx, '\n');
+            app.input_text = chars.into_iter().collect();
+            app.input_cursor = insert_idx;
+            app.set_input_mode(InputMode::Insert);
+        }
+        Some(Action::DeleteLine) => {
+            let chars: Vec<char> = app.input_text.chars().collect();
+            if !chars.is_empty() {
+                let mut line_start = 0;
+                for i in (0..app.input_cursor).rev() {
+                    if chars.get(i) == Some(&'\n') {
+                        line_start = i + 1;
+                        break;
+                    }
+                }
+
+                let mut line_end = chars.len();
+                for (i, c) in chars.iter().enumerate().skip(app.input_cursor) {
+                    if *c == '\n' {
+                        line_end = i;
+                        break;
+                    }
+                }
+
+                let mut delete_start = line_start;
+                let mut delete_end = line_end;
+
+                if line_end < chars.len() && chars[line_end] == '\n' {
+                    delete_end += 1;
+                } else if line_start > 0 && chars[line_start - 1] == '\n' {
+                    delete_start -= 1;
+                }
+
+                let yank_content: String = chars[line_start..line_end].iter().collect();
+                app.yank_buffer = Some(format!("{}\n", yank_content));
+
+                let mut new_chars = Vec::new();
+                new_chars.extend_from_slice(&chars[0..delete_start]);
+                new_chars.extend_from_slice(&chars[delete_end..chars.len()]);
+
+                app.input_text = new_chars.into_iter().collect();
+
+                let chars_after: Vec<char> = app.input_text.chars().collect();
+                if chars_after.is_empty() {
+                    app.input_cursor = 0;
+                } else if delete_start < chars_after.len() {
+                    app.input_cursor = delete_start;
+                } else {
+                    let mut new_start = 0;
+                    for i in (0..chars_after.len()).rev() {
+                        if chars_after[i] == '\n' {
+                            new_start = i + 1;
+                            break;
+                        }
+                    }
+                    app.input_cursor = new_start;
+                }
+            }
+        }
+        Some(Action::AppendCharacter(c)) => {
+            let mut chars: Vec<char> = app.input_text.chars().collect();
+            if app.input_cursor <= chars.len() {
+                chars.insert(app.input_cursor, c);
+                app.input_text = chars.into_iter().collect();
+                app.input_cursor += 1;
+            }
+        }
+        Some(Action::RemoveCharacter) => {
+            if app.input_cursor > 0 {
+                let mut chars: Vec<char> = app.input_text.chars().collect();
+                chars.remove(app.input_cursor - 1);
+                app.input_text = chars.into_iter().collect();
+                app.input_cursor -= 1;
+            }
+        }
+        Some(Action::Escape) => {
+            if matches!(app.input_state.input_mode, InputMode::Insert) && app.input_cursor > 0 {
+                let chars: Vec<char> = app.input_text.chars().collect();
+                if chars.get(app.input_cursor - 1) != Some(&'\n') {
+                    app.input_cursor -= 1;
+                }
+            }
+            app.set_input_mode(InputMode::Normal);
+        }
+        Some(Action::Enter)
+            if matches!(
+                app.input_state.input_mode,
+                InputMode::Insert | InputMode::Normal
+            ) =>
+        {
+            let content = app.input_text.trim().to_string();
+            if !content.is_empty()
+                && let Some(channel) = app.store.dm_channels.get(app.selected_dm_index)
+            {
+                let channel_id = channel.id.clone();
+                let api_client = app.api_client.clone();
+
+                tokio::spawn(async move {
+                    #[derive(serde::Serialize)]
+                    struct SendMessagePayload {
+                        content: String,
+                        nonce: String,
+                    }
+
+                    let payload = SendMessagePayload {
+                        content,
+                        nonce: ulid::Ulid::generate().to_string(),
+                    };
+
+                    if let Err(e) = api_client
+                        .post::<serde_json::Value, _>(
+                            crate::api::client::Endpoint::SendMessage(channel_id),
+                            &payload,
+                        )
+                        .await
+                    {
+                        log::error!("Failed to send message: {}", e);
+                    }
+                });
+            }
+            app.input_text.clear();
+            app.input_cursor = 0;
+            app.set_input_mode(InputMode::Normal);
+        }
+        _ => {}
+    }
+}
diff --git a/src/handlers/dm_list.rs b/src/handlers/dm_list.rs
new file mode 100644
index 0000000..dc40476
--- /dev/null
+++ b/src/handlers/dm_list.rs
@@ -0,0 +1,142 @@
+use log::error;
+use ratatui::crossterm::event::KeyEvent;
+
+use crate::{
+    action::Action,
+    app::{App, AppEvent, AppState},
+    input::InputMode,
+};
+
+pub fn handle(app: &mut App, key: KeyEvent) {
+    let action = app.input_state.process_key_event(key);
+    match action {
+        Some(Action::Quit) => app.should_quit = true,
+        Some(Action::EnterCommandMode) => {
+            app.command_text.clear();
+            app.set_input_mode(InputMode::Command);
+        }
+        Some(Action::CursorUp) => {
+            if app.selected_dm_index > 0 {
+                app.selected_dm_index -= 1;
+            }
+        }
+        Some(Action::CursorDown) => {
+            let total_items = app.store.dm_channels.len();
+            if total_items > 0 && app.selected_dm_index + 1 < total_items {
+                app.selected_dm_index += 1;
+            }
+        }
+        Some(Action::GoToTopUI) => {
+            app.selected_dm_index = 0;
+        }
+        Some(Action::Enter) if !app.store.dm_channels.is_empty() => {
+            let channel_id = app.store.dm_channels[app.selected_dm_index].id.clone();
+            app.store.dm_channels[app.selected_dm_index].has_unread = false;
+            app.state = AppState::Dm;
+            app.set_input_mode(InputMode::Normal);
+            app.is_loading_messages = true;
+            app.store.current_dm_messages.clear();
+            app.input_text.clear();
+
+            let api_client = app.api_client.clone();
+            let app_tx = app.app_tx.clone();
+            let users = app.store.users.clone();
+
+            tokio::spawn(async move {
+                let query = crate::api::channel::MessageHistoryQuery {
+                    limit: Some(50),
+                    before: None,
+                    after: None,
+                    sort: None,
+                    nearby: None,
+                };
+                match crate::api::channel::fetch_message_history(
+                    &api_client,
+                    &channel_id,
+                    Some(&query),
+                )
+                .await
+                {
+                    Ok(messages_json) => {
+                        let mut parsed_messages = Vec::with_capacity(messages_json.len());
+                        let mut new_users_fetched = Vec::new();
+                        let mut local_users = users.clone();
+
+                        for msg in messages_json {
+                            let id = msg
+                                .get("_id")
+                                .and_then(|v| v.as_str())
+                                .unwrap_or("unknown")
+                                .to_string();
+
+                            let author_id = msg
+                                .get("author")
+                                .and_then(|v| v.as_str())
+                                .unwrap_or("Unknown")
+                                .to_string();
+
+                            let mut author_name = author_id.clone();
+                            if let Some(user) = local_users.get(&author_id) {
+                                author_name = user.username.clone();
+                            } else if author_id != "Unknown"
+                                && let Ok(user_val) = api_client
+                                    .get::<serde_json::Value>(crate::api::client::Endpoint::User(
+                                        author_id.clone(),
+                                    ))
+                                    .await
+                                && let Some(username) =
+                                    user_val.get("username").and_then(|v| v.as_str())
+                            {
+                                author_name = username.to_string();
+                                let new_user = crate::models::User {
+                                    id: author_id.clone(),
+                                    username: username.to_string(),
+                                };
+                                local_users.insert(author_id.clone(), new_user.clone());
+                                new_users_fetched.push(new_user);
+                            }
+
+                            let content = if let Some(content_val) =
+                                msg.get("content").and_then(|v| v.as_str())
+                            {
+                                content_val.to_string()
+                            } else if let Some(sys) = msg.get("system") {
+                                format!(
+                                    "[System message: {}]",
+                                    sys.get("type")
+                                        .and_then(|v| v.as_str())
+                                        .unwrap_or("unknown")
+                                )
+                            } else {
+                                "[Unsupported message]".to_string()
+                            };
+
+                            parsed_messages.push(crate::models::Message {
+                                id,
+                                author_id,
+                                author_name,
+                                content,
+                            });
+                        }
+
+                        app_tx
+                            .send(AppEvent::DmMessagesLoaded(
+                                parsed_messages,
+                                new_users_fetched,
+                            ))
+                            .await
+                            .ok();
+                    }
+                    Err(e) => {
+                        error!("Error fetching messages: {e}");
+                        app_tx
+                            .send(AppEvent::DmMessagesLoaded(Vec::new(), Vec::new()))
+                            .await
+                            .ok();
+                    }
+                }
+            });
+        }
+        _ => {}
+    }
+}
diff --git a/src/handlers/error.rs b/src/handlers/error.rs
new file mode 100644
index 0000000..d1bb706
--- /dev/null
+++ b/src/handlers/error.rs
@@ -0,0 +1,9 @@
+use ratatui::crossterm::event::{KeyCode, KeyEvent};
+
+use crate::app::{App, AppState};
+
+pub fn handle(app: &mut App, key: KeyEvent) {
+    if matches!(key.code, KeyCode::Char(_) | KeyCode::Esc | KeyCode::Enter) {
+        app.state = AppState::InputToken;
+    }
+}
diff --git a/src/handlers/input_token.rs b/src/handlers/input_token.rs
new file mode 100644
index 0000000..c20f98d
--- /dev/null
+++ b/src/handlers/input_token.rs
@@ -0,0 +1,66 @@
+use ratatui::crossterm::event::{KeyCode, KeyEvent};
+
+use crate::app::{App, AppState};
+
+pub async fn handle(app: &mut App, key: KeyEvent) {
+    match key.code {
+        KeyCode::Enter => {
+            if !app.input_text.is_empty() {
+                app.state = AppState::ValidatingToken;
+                match app
+                    .auth
+                    .validate_token(&app.input_text, Some(app.api_base_url.clone()))
+                    .await
+                {
+                    Ok(client) => match app.auth.store_token(&app.input_text).await {
+                        Ok(_) => {
+                            app.api_client = client;
+                            let token = app.api_client.clone_token();
+                            if let Err(e) = app.authenticate_ws(&token).await {
+                                app.state = AppState::Error(e);
+                                return;
+                            }
+                            if let Ok(me_val) = app
+                                .api_client
+                                .get::<serde_json::Value>(crate::api::client::Endpoint::CurrentUser)
+                                .await
+                                && let (Some(my_id), Some(my_username)) = (
+                                    me_val.get("_id").and_then(|v| v.as_str()),
+                                    me_val.get("username").and_then(|v| v.as_str()),
+                                )
+                                && let Ok(uid) = crate::cache::Id::<crate::models::User>::new(my_id)
+                            {
+                                let user = crate::models::User {
+                                    id: my_id.to_string(),
+                                    username: my_username.to_string(),
+                                };
+                                let mut cache_locked = app.cache.lock().await;
+                                cache_locked.set(uid, &user).ok();
+                                app.store.users.insert(user.id.clone(), user);
+                            }
+                            app.state = AppState::LoggedIn;
+                        }
+                        Err(detailed_err) => {
+                            app.state = AppState::Error(detailed_err);
+                        }
+                    },
+                    Err(e) => {
+                        app.state = AppState::Error(e);
+                    }
+                }
+            }
+        }
+        KeyCode::Char(c) => {
+            app.input_text.push(c);
+            app.input_cursor += 1;
+        }
+        KeyCode::Backspace => {
+            app.input_text.pop();
+            app.input_cursor = app.input_cursor.saturating_sub(1);
+        }
+        KeyCode::Esc => {
+            app.should_quit = true;
+        }
+        _ => {}
+    }
+}
diff --git a/src/handlers/logged_in.rs b/src/handlers/logged_in.rs
new file mode 100644
index 0000000..2c8541d
--- /dev/null
+++ b/src/handlers/logged_in.rs
@@ -0,0 +1,56 @@
+use log::error;
+use ratatui::crossterm::event::KeyEvent;
+
+use crate::{
+    action::Action,
+    app::{App, AppEvent, AppState},
+    input::InputMode,
+};
+
+pub fn handle(app: &mut App, key: KeyEvent) {
+    let action = app.input_state.process_key_event(key);
+    match action {
+        Some(Action::Quit) => app.should_quit = true,
+        Some(Action::EnterCommandMode) => {
+            app.command_text.clear();
+            app.set_input_mode(InputMode::Command);
+        }
+        Some(Action::Enter) => {
+            if app.selected_index == 0 {
+                app.selected_dm_index = 0;
+                app.state = AppState::DmList;
+                app.is_loading_dms = true;
+
+                let users = app.store.users.clone();
+                let api_client = app.api_client.clone();
+                let app_tx = app.app_tx.clone();
+
+                tokio::spawn(async move {
+                    match crate::api::dm::fetch_dms(&api_client, &users).await {
+                        Ok((dms, new_users)) => {
+                            app_tx.send(AppEvent::DmsLoaded(dms, new_users)).await.ok();
+                        }
+                        Err(e) => {
+                            error!("Error fetching DMs in background: {e}");
+                        }
+                    }
+                });
+            }
+        }
+        Some(Action::CursorUp) => {
+            if app.selected_index > 0 {
+                app.selected_index -= 1;
+            }
+        }
+        Some(Action::CursorDown) => {
+            let total_items = 1 + app.store.servers.len();
+            if total_items > 0 && app.selected_index + 1 < total_items {
+                app.selected_index += 1;
+            }
+        }
+        Some(Action::GoToTopUI) => {
+            app.selected_index = 0;
+        }
+        _ => {}
+    }
+}
diff --git a/src/handlers/mod.rs b/src/handlers/mod.rs
new file mode 100644
index 0000000..333f330
--- /dev/null
+++ b/src/handlers/mod.rs
@@ -0,0 +1,6 @@
+pub mod command;
+pub mod dm;
+pub mod dm_list;
+pub mod error;
+pub mod input_token;
+pub mod logged_in;
diff --git a/src/input.rs b/src/input.rs
index 6519d23..195e2b8 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -4,7 +4,7 @@ use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
 use crate::action::Action;
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum InputMode {
     #[allow(unused)]
     Normal,
@@ -17,6 +17,17 @@ pub enum InputMode {
     Visual,
 }
 
+impl InputMode {
+    pub fn color(&self) -> ratatui::style::Color {
+        match self {
+            InputMode::Normal | InputMode::UI => ratatui::style::Color::Blue,
+            InputMode::Insert => ratatui::style::Color::Yellow,
+            InputMode::Visual => ratatui::style::Color::Magenta,
+            InputMode::Command => ratatui::style::Color::Green,
+        }
+    }
+}
+
 struct KeyMaps {
     ui: HashMap<Vec<KeyEvent>, Action>,
     normal: HashMap<Vec<KeyEvent>, Action>,
@@ -24,6 +35,147 @@ struct KeyMaps {
     typing: HashMap<Vec<KeyEvent>, Action>,
 }
 
+impl Default for KeyMaps {
+    fn default() -> Self {
+        let ui_maps = HashMap::from([
+            (
+                vec![KeyEvent::new(KeyCode::Char(':'), KeyModifiers::NONE)],
+                Action::EnterCommandMode,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char(':'), KeyModifiers::SHIFT)],
+                Action::EnterCommandMode,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)],
+                Action::Enter,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE)],
+                Action::EnterInsertMode,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE)],
+                Action::EnterInsertModeAfter,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('I'), KeyModifiers::SHIFT)],
+                Action::EnterInsertModeLineStart,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('A'), KeyModifiers::SHIFT)],
+                Action::EnterInsertModeLineEnd,
+            ),
+            (
+                vec![
+                    KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE),
+                    KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE),
+                ],
+                Action::DeleteLine,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)],
+                Action::OpenNewLineBelow,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('O'), KeyModifiers::SHIFT)],
+                Action::OpenNewLineAbove,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE)],
+                Action::CursorLeft,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('l'), KeyModifiers::NONE)],
+                Action::CursorRight,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)],
+                Action::CursorLeft,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Right, KeyModifiers::NONE)],
+                Action::CursorRight,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)],
+                Action::Escape,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE)],
+                Action::CursorDown,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Down, KeyModifiers::NONE)],
+                Action::CursorDown,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('k'), KeyModifiers::NONE)],
+                Action::CursorUp,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)],
+                Action::CursorUp,
+            ),
+            (
+                vec![
+                    KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE),
+                    KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE),
+                ],
+                Action::GoToTopUI,
+            ),
+            (
+                vec![KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)],
+                Action::Quit,
+            ),
+        ]);
+
+        Self {
+            ui: ui_maps.clone(),
+            normal: ui_maps,
+            visual: HashMap::new(),
+            typing: HashMap::from([
+                (
+                    vec![KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)],
+                    Action::RemoveCharacter,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)],
+                    Action::Enter,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT)],
+                    Action::AppendCharacter('\n'),
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT)],
+                    Action::AppendCharacter('\n'),
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)],
+                    Action::CursorLeft,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Right, KeyModifiers::NONE)],
+                    Action::CursorRight,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)],
+                    Action::CursorUp,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Down, KeyModifiers::NONE)],
+                    Action::CursorDown,
+                ),
+                (
+                    vec![KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)],
+                    Action::Escape,
+                ),
+            ]),
+        }
+    }
+}
+
 pub struct InputState {
     pub input_mode: InputMode,
     pending_keys: Vec<KeyEvent>,
@@ -35,49 +187,18 @@ impl Default for InputState {
         Self {
             input_mode: InputMode::UI,
             pending_keys: Vec::with_capacity(2),
-            key_maps: KeyMaps {
-                ui: HashMap::from([(
-                    vec![KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)],
-                    Action::Quit,
-                )]),
-                normal: HashMap::new(),
-                visual: HashMap::new(),
-                typing: HashMap::from([
-                    (
-                        vec![KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)],
-                        Action::RemoveCharacter,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)],
-                        Action::Enter,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)],
-                        Action::CursorLeft,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Right, KeyModifiers::NONE)],
-                        Action::CursorRight,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)],
-                        Action::CursorUp,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Down, KeyModifiers::NONE)],
-                        Action::CursorDown,
-                    ),
-                    (
-                        vec![KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)],
-                        Action::Escape,
-                    ),
-                ]),
-            },
+            key_maps: KeyMaps::default(),
         }
     }
 }
 
 impl InputState {
+    #[allow(unused)]
+    pub fn change_input_mode(&mut self, new_mode: InputMode) {
+        self.pending_keys.clear();
+        self.input_mode = new_mode;
+    }
+
     /// Gets respective keymap based on input mode
     fn key_map(&self) -> &HashMap<Vec<KeyEvent>, Action> {
         match self.input_mode {
@@ -101,20 +222,104 @@ impl InputState {
     pub fn process_key_event(&mut self, key_event: KeyEvent) -> Option<Action> {
         self.pending_keys.push(key_event);
         let key_map = self.key_map();
-
-        let action =
-            key_map
-                .get(&self.pending_keys)
-                .cloned()
-                .or(match (self.input_mode, key_event.code) {
-                    (InputMode::Insert | InputMode::Command, KeyCode::Char(c)) => {
-                        Some(Action::AppendCharacter(c))
-                    }
-                    _ => None,
-                });
+        let action = key_map
+            .get(&self.pending_keys)
+            .cloned()
+            .or(self.handle_typing_event(key_event));
         if action.is_some() || !self.has_potential_pending_key_bindings() {
             self.pending_keys.clear();
         }
         action
     }
+
+    pub fn handle_typing_event(&self, key_event: KeyEvent) -> Option<Action> {
+        match (self.input_mode, key_event.code) {
+            (InputMode::Insert | InputMode::Command, KeyCode::Char(c)) => {
+                match key_event.modifiers {
+                    KeyModifiers::SHIFT => Some(Action::AppendCharacter(c.to_ascii_uppercase())),
+                    KeyModifiers::NONE => Some(Action::AppendCharacter(c)),
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+
+    use crate::{
+        action::Action,
+        input::{InputMode, InputState},
+    };
+
+    #[test]
+    fn single_key_motions() {
+        let mut state = InputState::default();
+        for _ in 0..2 {
+            assert_eq!(
+                state.process_key_event(KeyEvent::new(KeyCode::Null, KeyModifiers::NONE)),
+                None,
+                "Should have no action"
+            );
+            assert_eq!(
+                state.process_key_event(KeyEvent::new(KeyCode::Char(':'), KeyModifiers::NONE)),
+                Some(Action::EnterCommandMode),
+                "Should have done the enter command mode action"
+            );
+        }
+    }
+
+    #[test]
+    fn typing_motions() {
+        let mut state = InputState::default();
+        state.change_input_mode(InputMode::Insert);
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)),
+            Some(Action::AppendCharacter('q')),
+            "Should have done appened q"
+        );
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
+            Some(Action::AppendCharacter('r')),
+            "Should have appened r"
+        );
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
+            Some(Action::AppendCharacter('R')),
+            "Should have appened R"
+        );
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Null, KeyModifiers::NONE)),
+            None,
+            "Should have no action"
+        );
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)),
+            Some(Action::CursorLeft),
+            "Should have moved the cursor left"
+        );
+    }
+
+    #[test]
+    fn multi_keybinding_shortcuts() {
+        let mut state = InputState::default();
+        assert!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE))
+                != Some(Action::GoToTopUI),
+            "Should not called action early"
+        );
+        assert_eq!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE)),
+            Some(Action::GoToTopUI),
+            "Should have go to top UI after second g"
+        );
+        assert!(
+            state.process_key_event(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE))
+                != Some(Action::GoToTopUI),
+            "Should have cleared pending keys"
+        );
+    }
 }
diff --git a/src/main.rs b/src/main.rs
index af3f991..1865052 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,13 +2,19 @@ mod action;
 mod api;
 mod app;
 mod cache;
+mod command;
 mod error;
+mod handlers;
 mod input;
+mod models;
+mod notification;
 mod ui;
 
 use std::{fs, path::PathBuf};
 
+use crate::{api::client::Endpoint, cache::Id};
 use app::App;
+use log::debug;
 use ratatui::crossterm::event::{self, Event};
 
 pub const LOG_FILE: &str = "logs";
@@ -46,7 +52,43 @@ async fn main() -> anyhow::Result<(), Box<dyn std::error::Error>> {
 
     let mut terminal = ratatui::init();
 
-    let mut app = App::new().await?;
+    ratatui::crossterm::execute!(
+        std::io::stdout(),
+        ratatui::crossterm::event::PushKeyboardEnhancementFlags(
+            ratatui::crossterm::event::KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+        ),
+        ratatui::crossterm::cursor::SetCursorStyle::BlinkingBlock
+    )
+    .ok();
+
+    let api_base_url = std::env::var("API_BASE_URL").ok();
+    let ws_base_url = std::env::var("WS_BASE_URL").ok();
+
+    let mut app = App::new(api_base_url.clone(), ws_base_url.clone()).await?;
+
+    if matches!(app.state, app::AppState::LoggedIn) {
+        let token = app.api_client.clone_token();
+        app.authenticate_ws(&token).await?;
+
+        if let Ok(me_val) = app
+            .api_client
+            .get::<serde_json::Value>(Endpoint::CurrentUser)
+            .await
+            && let (Some(my_id), Some(my_username)) = (
+                me_val.get("_id").and_then(|v| v.as_str()),
+                me_val.get("username").and_then(|v| v.as_str()),
+            )
+            && let Ok(uid) = Id::<crate::models::User>::new(my_id)
+        {
+            let user = crate::models::User {
+                id: my_id.to_string(),
+                username: my_username.to_string(),
+            };
+            let mut cache_locked = app.cache.lock().await;
+            cache_locked.set(uid, &user).ok();
+            app.store.users.insert(user.id.clone(), user);
+        }
+    }
 
     loop {
         terminal.draw(|f| ui::render(f, &app))?;
@@ -62,8 +104,131 @@ async fn main() -> anyhow::Result<(), Box<dyn std::error::Error>> {
                 break;
             }
         }
+
+        while let Ok(event) = app.app_rx.try_recv() {
+            app.handle_app_event(event);
+        }
+
+        while let Ok(event) = app.ws_rx.try_recv() {
+            debug!("Received WebSocket event: {event:?}");
+            api::ws::EventHandler::new(&mut app.store.servers).handle_event(&event);
+
+            if let crate::api::events::ServerEvent::Message(msg_val) = &event {
+                let msg_val = msg_val.clone();
+                let api_client = app.api_client.clone();
+                let app_tx = app.app_tx.clone();
+                let local_users = app.store.users.clone();
+
+                tokio::spawn(async move {
+                    if let Some(channel_id) = msg_val.get("channel").and_then(|v| v.as_str()) {
+                        let id = msg_val
+                            .get("_id")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("unknown")
+                            .to_string();
+                        let author_id = msg_val
+                            .get("author")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("Unknown")
+                            .to_string();
+                        let channel_id = channel_id.to_string();
+
+                        let mut author_name = author_id.clone();
+                        let mut new_user_fetched = None;
+
+                        if let Some(user) = local_users.get(&author_id) {
+                            author_name = user.username.clone();
+                        } else if author_id != "Unknown"
+                            && let Ok(user_val) = api_client
+                                .get::<serde_json::Value>(crate::api::client::Endpoint::User(
+                                    author_id.clone(),
+                                ))
+                                .await
+                            && let Some(username) =
+                                user_val.get("username").and_then(|v| v.as_str())
+                        {
+                            author_name = username.to_string();
+                            let new_user = crate::models::User {
+                                id: author_id.clone(),
+                                username: username.to_string(),
+                            };
+                            new_user_fetched = Some(new_user);
+                        }
+
+                        let content = if let Some(content_val) =
+                            msg_val.get("content").and_then(|v| v.as_str())
+                        {
+                            content_val.to_string()
+                        } else if let Some(sys) = msg_val.get("system") {
+                            format!(
+                                "[System message: {}]",
+                                sys.get("type")
+                                    .and_then(|v| v.as_str())
+                                    .unwrap_or("unknown")
+                            )
+                        } else {
+                            "[Unsupported message]".to_string()
+                        };
+
+                        let message = crate::models::Message {
+                            id,
+                            author_id,
+                            author_name,
+                            content,
+                        };
+
+                        app_tx
+                            .send(app::AppEvent::NewMessage {
+                                channel_id,
+                                message,
+                                new_user: new_user_fetched,
+                            })
+                            .await
+                            .ok();
+                    }
+                });
+            } else if let crate::api::events::ServerEvent::MessageUpdate { id, channel, data } =
+                &event
+            {
+                if let Some(content) = data.get("content").and_then(|v| v.as_str()) {
+                    app.app_tx
+                        .try_send(app::AppEvent::MessageUpdated {
+                            channel_id: channel.clone(),
+                            message_id: id.clone(),
+                            content: content.to_string(),
+                        })
+                        .ok();
+                }
+            } else if let crate::api::events::ServerEvent::MessageDelete { id, channel } = &event {
+                app.app_tx
+                    .try_send(app::AppEvent::MessageDeleted {
+                        channel_id: channel.clone(),
+                        message_id: id.clone(),
+                    })
+                    .ok();
+            }
+        }
     }
 
+    {
+        let mut cache_locked = app.cache.lock().await;
+        for user in app.store.users.values() {
+            if let Ok(uid) = crate::cache::Id::<crate::models::User>::new(&user.id) {
+                let _ = cache_locked.set(uid, user);
+            }
+        }
+        if let Err(e) = cache_locked.dump() {
+            log::error!("Failed to dump cache to disk: {}", e);
+        }
+    }
+
+    ratatui::crossterm::execute!(
+        std::io::stdout(),
+        ratatui::crossterm::event::PopKeyboardEnhancementFlags,
+        ratatui::crossterm::cursor::SetCursorStyle::DefaultUserShape
+    )
+    .ok();
+
     ratatui::restore();
     Ok(())
 }
diff --git a/src/models.rs b/src/models.rs
new file mode 100644
index 0000000..ba51616
--- /dev/null
+++ b/src/models.rs
@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct Server {
+    pub id: String,
+    pub name: String,
+    pub description: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct DirectMessageChannel {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub has_unread: bool,
+    pub last_message_preview: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct User {
+    pub id: String,
+    pub username: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Message {
+    pub id: String,
+    pub author_id: String,
+    pub author_name: String,
+    pub content: String,
+}
diff --git a/src/notification.rs b/src/notification.rs
new file mode 100644
index 0000000..46023fa
--- /dev/null
+++ b/src/notification.rs
@@ -0,0 +1,81 @@
+#![allow(dead_code)]
+
+use log::{error, warn};
+use notify_rust::{Notification, ResponseHandler, Timeout};
+use std::{fs, path::PathBuf, thread};
+
+use crate::Result;
+
+pub const ICON_FILE: &str = "icon"; // Extension omitted pending final icon format determination
+pub const NOTIFICATION_TIMEOUT: u32 = 10_000;
+
+fn get_icon_path() -> Option<PathBuf> {
+    let mut icon_path = dirs::data_dir()?;
+    icon_path.push(env!("CARGO_PKG_NAME"));
+
+    if let Err(e) = fs::create_dir_all(&icon_path) {
+        error!("Error creating data directory: {e:?}");
+        return None;
+    };
+
+    icon_path.push(ICON_FILE);
+    Some(icon_path)
+}
+
+pub struct NotifyHandler {
+    icon_path: Option<PathBuf>,
+}
+
+impl NotifyHandler {
+    pub async fn new() -> Result<Self> {
+        let icon_path = get_icon_path();
+        if icon_path.is_none() {
+            warn!("Failed to find icon path!");
+        }
+
+        Ok(Self { icon_path })
+    }
+
+    pub fn clone_icon_path(&self) -> String {
+        self.icon_path
+            .clone()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string()
+    }
+
+    pub async fn send_notification(
+        &self,
+        title: String,
+        body: String,
+        icon: String,
+        actions: Vec<(String, String)>,
+        response: impl ResponseHandler + Send + 'static,
+    ) {
+        thread::spawn(move || {
+            let mut notification = Notification::new()
+                .appname(env!("CARGO_PKG_NAME"))
+                .summary(&title)
+                .body(&body)
+                .timeout(Timeout::Milliseconds(NOTIFICATION_TIMEOUT))
+                .icon(&icon)
+                .clone();
+
+            for action in actions {
+                notification.action(&action.0, &action.1);
+            }
+
+            let res = notification.show();
+            match res {
+                Ok(handle) => {
+                    if let Err(e) = handle.wait_for_response(response) {
+                        error!("Error fetching notification response: {e:?}");
+                    };
+                }
+                Err(e) => {
+                    error!("Error sending notification: {e:?}");
+                }
+            }
+        });
+    }
+}
diff --git a/src/ui/dm.rs b/src/ui/dm.rs
new file mode 100644
index 0000000..7a43d93
--- /dev/null
+++ b/src/ui/dm.rs
@@ -0,0 +1,176 @@
+use crate::app::App;
+use ratatui::{
+    Frame,
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Paragraph},
+};
+
+pub fn render(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
+    let border_color = app.input_state.input_mode.color();
+
+    let title = if let Some(channel) = app.store.dm_channels.get(app.selected_dm_index) {
+        format!(" Direct Message: {} ", channel.name)
+    } else {
+        " Direct Message ".to_string()
+    };
+
+    let block = Block::default()
+        .title(title)
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(border_color));
+
+    if app.is_loading_messages {
+        let msg = Paragraph::new("Loading messages...")
+            .style(Style::default().fg(Color::Yellow))
+            .block(block);
+        f.render_widget(msg, area);
+        return;
+    }
+
+    if app.store.current_dm_messages.is_empty() {
+        let msg = Paragraph::new("No messages found. (Type :q to return)")
+            .style(Style::default().fg(Color::DarkGray))
+            .block(block);
+        f.render_widget(msg, area);
+        return;
+    }
+
+    let mut message_lines = Vec::new();
+
+    // Revolt API returns messages in descending order (newest first).
+    // We reverse to render oldest at top and newest at bottom.
+    for msg in app.store.current_dm_messages.iter().rev() {
+        let mut first = true;
+        for line_str in msg.content.split('\n') {
+            if first {
+                let author_span = Span::styled(
+                    format!("{}: ", msg.author_name),
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::BOLD),
+                );
+                let content_span = Span::raw(line_str);
+                message_lines.push(Line::from(vec![author_span, content_span]));
+                first = false;
+            } else {
+                message_lines.push(Line::from(vec![Span::raw(line_str)]));
+            }
+        }
+    }
+
+    let text_width = area.width.saturating_sub(2).max(1) as usize;
+    let mut input_lines = 0;
+    let split_lines: Vec<&str> = app.input_text.split('\n').collect();
+
+    for (i, line) in split_lines.iter().enumerate() {
+        let chars = line.chars().count();
+        if i == split_lines.len() - 1 {
+            input_lines += (chars / text_width) + 1;
+        } else if chars == 0 {
+            input_lines += 1;
+        } else {
+            input_lines += chars.div_ceil(text_width);
+        }
+    }
+
+    let input_height = (input_lines as u16) + 2; // +2 for borders
+
+    let chunks = ratatui::layout::Layout::default()
+        .direction(ratatui::layout::Direction::Vertical)
+        .constraints([
+            ratatui::layout::Constraint::Min(0),
+            ratatui::layout::Constraint::Length(input_height),
+        ])
+        .split(area);
+
+    let messages_area = chunks[0];
+    let input_area = chunks[1];
+
+    let msg_text_width = messages_area.width.saturating_sub(2).max(1) as usize;
+    let mut total_msg_lines = 0;
+
+    for line in &message_lines {
+        let chars = line
+            .spans
+            .iter()
+            .map(|s| s.content.chars().count())
+            .sum::<usize>();
+        if chars == 0 {
+            total_msg_lines += 1;
+        } else {
+            total_msg_lines += chars.div_ceil(msg_text_width);
+        }
+    }
+
+    let scroll =
+        total_msg_lines.saturating_sub(messages_area.height.saturating_sub(2) as usize) as u16;
+
+    let msg_paragraph = Paragraph::new(message_lines)
+        .block(block)
+        .wrap(ratatui::widgets::Wrap { trim: false })
+        .scroll((scroll, 0));
+
+    f.render_widget(msg_paragraph, messages_area);
+
+    let input_border_color = app.input_state.input_mode.color();
+
+    let input_block = Block::default()
+        .title(" Message (Type 'i' to insert, ESC for normal) ")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(input_border_color));
+
+    let input_paragraph = Paragraph::new(app.input_text.as_str())
+        .block(input_block)
+        .wrap(ratatui::widgets::Wrap { trim: false });
+
+    f.render_widget(input_paragraph, input_area);
+
+    if matches!(
+        app.input_state.input_mode,
+        crate::input::InputMode::Insert | crate::input::InputMode::Normal
+    ) {
+        let mut cursor_line_idx = 0;
+        let mut cursor_char_idx = 0;
+        let mut chars_counted = 0;
+
+        for (i, line) in split_lines.iter().enumerate() {
+            let line_len = line.chars().count();
+            let len_with_nl = if i == split_lines.len() - 1 {
+                line_len
+            } else {
+                line_len + 1
+            };
+
+            if app.input_cursor >= chars_counted && app.input_cursor < chars_counted + len_with_nl {
+                cursor_line_idx = i;
+                cursor_char_idx = app.input_cursor - chars_counted;
+                break;
+            } else if i == split_lines.len() - 1 && app.input_cursor >= chars_counted + len_with_nl
+            {
+                cursor_line_idx = i;
+                cursor_char_idx = line_len;
+            }
+            chars_counted += len_with_nl;
+        }
+
+        let mut base_y_offset = 0;
+        for line in split_lines.iter().take(cursor_line_idx) {
+            let chars = line.chars().count();
+            if chars == 0 {
+                base_y_offset += 1;
+            } else {
+                base_y_offset += chars.div_ceil(text_width);
+            }
+        }
+
+        let cursor_x = input_area.x + 1 + (cursor_char_idx % text_width) as u16;
+        let cursor_y =
+            input_area.y + 1 + base_y_offset as u16 + (cursor_char_idx / text_width) as u16;
+
+        let clamped_x = cursor_x.min(input_area.x + input_area.width.saturating_sub(2));
+        let clamped_y = cursor_y.min(input_area.y + input_area.height.saturating_sub(2));
+
+        f.set_cursor_position(ratatui::layout::Position::new(clamped_x, clamped_y));
+    }
+}
diff --git a/src/ui/dm_list.rs b/src/ui/dm_list.rs
new file mode 100644
index 0000000..7b27651
--- /dev/null
+++ b/src/ui/dm_list.rs
@@ -0,0 +1,120 @@
+use crate::app::App;
+use ratatui::{
+    Frame,
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, List, ListItem, ListState, Paragraph},
+};
+
+pub fn render(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
+    let total_items = app.store.dm_channels.len();
+
+    let border_color = app.input_state.input_mode.color();
+
+    if app.is_loading_dms && total_items == 0 {
+        let msg = Paragraph::new("Loading Direct Messages...")
+            .style(
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD),
+            )
+            .block(
+                Block::default()
+                    .title(" Direct Messages ")
+                    .borders(Borders::ALL)
+                    .border_style(Style::default().fg(border_color)),
+            );
+        f.render_widget(msg, area);
+        return;
+    }
+
+    if total_items == 0 {
+        let msg = Paragraph::new("No Direct Messages found. (Type :q to return)")
+            .style(Style::default().fg(Color::DarkGray))
+            .block(
+                Block::default()
+                    .title(" Direct Messages ")
+                    .borders(Borders::ALL)
+                    .border_style(Style::default().fg(border_color)),
+            );
+        f.render_widget(msg, area);
+        return;
+    }
+
+    let selected_index = app.selected_dm_index.min(total_items.saturating_sub(1));
+    let num_digits = total_items.to_string().len();
+
+    let mut items: Vec<ListItem> = Vec::new();
+
+    for (i, channel) in app.store.dm_channels.iter().enumerate() {
+        let is_selected = i == selected_index;
+        let rel_num = (i as isize - selected_index as isize).unsigned_abs();
+        let width = num_digits.max(2);
+
+        let line_num_str = if is_selected {
+            format!("{:<width$} ", i, width = width)
+        } else {
+            format!("{:>width$} ", rel_num, width = width)
+        };
+
+        let num_style = if is_selected {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::DarkGray)
+        };
+
+        let text_style = if is_selected {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::Cyan)
+        };
+
+        let mut spans = vec![
+            Span::styled(line_num_str, num_style),
+            Span::styled(channel.name.as_str(), text_style),
+        ];
+
+        if channel.has_unread {
+            spans.push(Span::styled(
+                " [*]",
+                Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
+            ));
+        }
+
+        if let Some(preview) = &channel.last_message_preview {
+            let mut short_preview = preview.replace('\n', " ");
+            if short_preview.chars().count() > 30 {
+                short_preview = short_preview.chars().take(27).collect();
+                short_preview.push_str("...");
+            }
+            spans.push(Span::styled(
+                format!(" - {}", short_preview),
+                Style::default().fg(Color::DarkGray),
+            ));
+        }
+
+        items.push(ListItem::new(Line::from(spans)));
+    }
+
+    let mut state = ListState::default();
+    state.select(Some(selected_index));
+
+    let list = List::new(items)
+        .block(
+            Block::default()
+                .title(" Direct Messages ")
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(border_color)),
+        )
+        .highlight_style(
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD),
+        );
+
+    f.render_stateful_widget(list, area, &mut state);
+}
diff --git a/src/ui/error.rs b/src/ui/error.rs
index 19b7b7f..2ca34af 100644
--- a/src/ui/error.rs
+++ b/src/ui/error.rs
@@ -5,13 +5,19 @@ use ratatui::{
 };
 
 pub fn render(f: &mut Frame, message: &str) {
-    let error_text = format!("CRITICAL SYSTEM ERROR:\n\n{message}\n\nPress any key to return...");
+    let title = if message.contains("keyring") || message.contains("Keyring") {
+        " Keyring Error "
+    } else if message.contains("connect") || message.contains("internet") {
+        " Connection Error "
+    } else if message.to_lowercase().contains("invalid token") {
+        " Authentication Error "
+    } else {
+        " Error "
+    };
+
+    let error_text = format!("{message}\n\nPress any key to return...");
     let error_msg = Paragraph::new(error_text)
         .style(Style::default().fg(Color::Red))
-        .block(
-            Block::default()
-                .title(" Keyring Failure ")
-                .borders(Borders::ALL),
-        );
+        .block(Block::default().title(title).borders(Borders::ALL));
     f.render_widget(error_msg, f.area());
 }
diff --git a/src/ui/input_token.rs b/src/ui/input_token.rs
index 5bf321d..9d616f0 100644
--- a/src/ui/input_token.rs
+++ b/src/ui/input_token.rs
@@ -27,4 +27,9 @@ pub fn render(f: &mut Frame, app: &App) {
     let input_block = Paragraph::new(app.input_text.as_str())
         .block(Block::default().title(" User Token ").borders(Borders::ALL));
     f.render_widget(input_block, chunks[1]);
+
+    // Clamp cursor X to the input box interior
+    let cursor_x = (chunks[1].x + 1 + app.input_cursor as u16)
+        .min(chunks[1].x + chunks[1].width.saturating_sub(2));
+    f.set_cursor_position(ratatui::layout::Position::new(cursor_x, chunks[1].y + 1));
 }
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index db8968f..ef1acb8 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -1,8 +1,9 @@
+mod dm;
+mod dm_list;
 mod error;
 mod input_token;
+mod render;
 mod server_list;
 mod validating_token;
 
-mod render;
-
 pub use render::render;
diff --git a/src/ui/render.rs b/src/ui/render.rs
index c58799c..07a8bb5 100644
--- a/src/ui/render.rs
+++ b/src/ui/render.rs
@@ -1,13 +1,56 @@
-use crate::app::{App, AppState};
-use ratatui::Frame;
+use crate::{
+    app::{App, AppState},
+    input::InputMode,
+};
+use ratatui::{
+    Frame,
+    layout::{Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Paragraph},
+};
 
-use super::{error, input_token, server_list, validating_token};
+use super::{dm, dm_list, error, input_token, server_list, validating_token};
 
 pub fn render(f: &mut Frame, app: &App) {
+    let is_command_mode = matches!(app.input_state.input_mode, InputMode::Command);
+
+    let (main_area, command_area) = if is_command_mode {
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Min(1), Constraint::Length(3)])
+            .split(f.area());
+        (chunks[0], Some(chunks[1]))
+    } else {
+        (f.area(), None)
+    };
+
     match &app.state {
         AppState::InputToken => input_token::render(f, app),
         AppState::ValidatingToken => validating_token::render(f),
-        AppState::LoggedIn => server_list::render(f, app),
-        AppState::Error(message) => error::render(f, message),
+        AppState::LoggedIn => server_list::render(f, app, main_area),
+        AppState::DmList => dm_list::render(f, app, main_area),
+        AppState::Dm => dm::render(f, app, main_area),
+        AppState::Error(message) => error::render(f, &message.to_string()),
+    }
+
+    if let Some(cmd_area) = command_area {
+        let cmd_widget = Paragraph::new(format!(":{}", app.command_text))
+            .style(
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD),
+            )
+            .block(
+                Block::default()
+                    .title(" Command ")
+                    .borders(Borders::ALL)
+                    .border_style(Style::default().fg(app.input_state.input_mode.color())),
+            );
+        f.render_widget(cmd_widget, cmd_area);
+
+        // Clamp cursor X to the command box interior
+        let cursor_x = (cmd_area.x + 2 + app.command_text.chars().count() as u16)
+            .min(cmd_area.x + cmd_area.width.saturating_sub(2));
+        f.set_cursor_position(ratatui::layout::Position::new(cursor_x, cmd_area.y + 1));
     }
 }
diff --git a/src/ui/server_list.rs b/src/ui/server_list.rs
index 7cb4e79..e144e8b 100644
--- a/src/ui/server_list.rs
+++ b/src/ui/server_list.rs
@@ -1,13 +1,92 @@
 use crate::app::App;
 use ratatui::{
     Frame,
-    style::{Color, Style},
-    widgets::{Block, Borders, Paragraph},
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, List, ListItem, ListState},
 };
 
-pub fn render(f: &mut Frame, _app: &App) {
-    let msg = Paragraph::new("Server list is not yet implemented.")
-        .style(Style::default().fg(Color::Yellow))
-        .block(Block::default().title(" Servers ").borders(Borders::ALL));
-    f.render_widget(msg, f.area());
+pub fn render(f: &mut Frame, app: &App, area: ratatui::layout::Rect) {
+    let total_items = 1 + app.store.servers.len();
+    let selected_index = app.selected_index.min(total_items.saturating_sub(1));
+
+    let num_digits = if total_items > 0 {
+        total_items.to_string().len()
+    } else {
+        1
+    };
+
+    let mut items: Vec<ListItem> = Vec::new();
+
+    for i in 0..total_items {
+        let is_selected = i == selected_index;
+        let rel_num = (i as isize - selected_index as isize).unsigned_abs();
+        let width = num_digits.max(2);
+
+        let line_num_str = if is_selected {
+            format!("{:<width$} ", i, width = width)
+        } else {
+            format!("{:>width$} ", rel_num, width = width)
+        };
+
+        let num_style = if is_selected {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::DarkGray)
+        };
+
+        let text_span = if i == 0 {
+            Span::styled(
+                "Direct Messages",
+                if is_selected {
+                    Style::default()
+                        .fg(Color::Yellow)
+                        .add_modifier(Modifier::BOLD)
+                } else {
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::BOLD)
+                },
+            )
+        } else {
+            let server_name = &app.store.servers[i - 1].name;
+            Span::styled(
+                server_name.as_str(),
+                if is_selected {
+                    Style::default()
+                        .fg(Color::Yellow)
+                        .add_modifier(Modifier::BOLD)
+                } else {
+                    Style::default().fg(Color::White)
+                },
+            )
+        };
+
+        items.push(ListItem::new(Line::from(vec![
+            Span::styled(line_num_str, num_style),
+            text_span,
+        ])));
+    }
+
+    let mut state = ListState::default();
+    state.select(Some(selected_index));
+
+    let border_color = app.input_state.input_mode.color();
+
+    let list = List::new(items)
+        .block(
+            Block::default()
+                .title(" Servers ")
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(border_color)),
+        )
+        .highlight_style(
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD),
+        );
+
+    f.render_stateful_widget(list, area, &mut state);
 }