diff --git a/Cargo.lock b/Cargo.lock
index 4026c84..5498801 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2776,6 +2776,8 @@ dependencies = [
  "bevy_xpbd_3d",
  "fastrand",
  "regex",
+ "serde",
+ "serde_yaml",
 ]
 
 [[package]]
@@ -3266,6 +3268,19 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -3673,6 +3688,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
 [[package]]
 name = "uuid"
 version = "1.7.0"
diff --git a/Cargo.toml b/Cargo.toml
index 138645b..069faed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,8 @@ bevy = { version = "0.13.1", default-features = false, features = ["jpeg", "bevy
 bevy_xpbd_3d = { version = "0.4.2", default-features = false, features = ["3d", "f64", "parry-f64", "parallel", "async-collider"] }
 bevy_embedded_assets = "0.10.2"
 fastrand = "2.0.2"
+serde = "1.0"
+serde_yaml = "0.9"
 
 [features]
 dev = ["bevy/dynamic_linking", "bevy/file_watcher"]
diff --git a/src/chat.rs b/src/chat.rs
index eef5710..67526fe 100644
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -1,304 +1,688 @@
-use bevy::prelude::*;
-use bevy_xpbd_3d::prelude::*;
-use bevy::math::DVec3;
 use crate::{actor, audio, hud, settings, world, effects};
+use bevy::prelude::*;
+use bevy::math::DVec3;
+use bevy_xpbd_3d::prelude::*;
+use serde_yaml::Value;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+pub const CHATS: &[&str] = &[
+    include_str!("chats/serenity.yaml"),
+    include_str!("chats/startrans.yaml"),
+];
+
+pub const TOKEN_CHAT: &str = "chat";
+pub const TOKEN_MSG: &str = "msg";
+pub const TOKEN_SYSTEM: &str = "system";
+pub const TOKEN_WARN: &str = "warn";
+pub const TOKEN_SLEEP: &str = "sleep";
+pub const TOKEN_SET: &str = "set";
+pub const TOKEN_IF: &str = "if";
+pub const TOKEN_GOTO: &str = "goto";
+pub const TOKEN_LABEL: &str = "label";
+pub const TOKEN_SCRIPT: &str = "script";
+pub const TOKEN_SOUND: &str = "sound";
+pub const TOKEN_NOWAIT: &str = "nowait";
+
+pub const TOKEN_INCLUDE: &str = "include";
+pub const TOKEN_GOTO_EXIT: &str = "EXIT";
+
+pub const DEFAULT_SOUND: &str = "chat";
+pub const MAX_BRANCH_DEPTH: usize = 64;
+
+pub const CHOICE_TIMER: f64 = 40.0 * settings::DEFAULT_CHAT_SPEED as f64;
+pub const LETTERS_PER_SECOND: f32 = 17.0;
+pub const TALKER_SPEED_FACTOR: f32 = settings::DEFAULT_CHAT_SPEED / LETTERS_PER_SECOND;
+pub const CHAT_SPEED_MIN_LEN: f32 = 40.0;
+
+pub const NON_CHOICE_TOKENS: &[&str] = &[
+    TOKEN_CHAT,
+    TOKEN_MSG,
+    TOKEN_SYSTEM,
+    TOKEN_WARN,
+    TOKEN_SLEEP,
+    TOKEN_SET,
+    TOKEN_IF,
+    TOKEN_GOTO,
+    TOKEN_LABEL,
+    TOKEN_SCRIPT,
+    TOKEN_SOUND,
+    TOKEN_NOWAIT,
+];
+pub const SKIPPABLE_TOKENS: &[&str] = &[
+    TOKEN_LABEL,
+    TOKEN_GOTO,
+    TOKEN_NOWAIT,
+];
 
 pub struct ChatPlugin;
 impl Plugin for ChatPlugin {
     fn build(&self, app: &mut App) {
-        app.register_type::<ChatBranch>();
+        app.add_systems(Startup, load_chats);
         app.add_systems(Update, (
-            handle_new_conversations,
-            handle_reply_keys,
-            handle_send_messages,
-            handle_conversations,
+            handle_reply_keys.before(handle_chat_timer),
+            handle_chat_timer.before(handle_chat_events),
+            handle_new_conversations.before(handle_chat_events),
+            handle_chat_events.before(handle_chat_scripts),
             handle_chat_scripts,
         ));
-        app.add_systems(PostUpdate, despawn_old_choices);
         app.add_event::<StartConversationEvent>();
-        app.add_event::<SendMessageEvent>();
+        app.add_event::<ChatEvent>();
         app.add_event::<ChatScriptEvent>();
+        app.insert_resource(ChatDB(Vec::new()));
     }
 }
 
+type ChatPos = Vec<usize>;
+
+#[derive(Component)]
+pub struct Chat {
+    pub id: usize,
+    pub position: ChatPos,
+    pub timer: f64,
+    pub talker: Talker,
+}
+
+#[derive(Component)]
+pub struct Choice {
+    pub text: String,
+    pub key: usize,
+    pub goto: ChatPos,
+}
+
+#[derive(Component)]
+#[derive(Clone)]
+pub struct Talker {
+    pub conv_id: String,
+    pub name: Option<String>,
+    pub pronoun: Option<String>,
+    pub talking_speed: f32,
+}
+
 #[derive(Event)]
 pub struct StartConversationEvent {
     pub talker: Talker,
 }
 
 #[derive(Event)]
-pub struct SendMessageEvent {
-    pub conv_id: String,
-    pub conv_label: String,
-    pub text: String,
-}
+pub struct ChatScriptEvent(String);
 
 #[derive(Event)]
-pub struct ChatScriptEvent {
-    name: String,
-    param: String,
-    param2: String,
+pub enum ChatEvent {
+    DespawnAllChoices,
+    DespawnAllChats,
+    SpawnMessage(String, hud::LogLevel, String),
+    SpawnChoice(String, usize, ChatPos, bool),
+    RunScript(String),
+    Sleep(f64),
+    //Script(String, String, String),
 }
 
-#[derive(Debug)]
-#[derive(Component, Reflect, Default)]
-#[reflect(Component)]
-pub struct ChatBranch {
-    pub id: String,
-    pub name: String,
-    pub label: String,
-    pub delay: f64,
-    pub sound: String,
-    pub level: String,
-    pub reply: String,
-    pub goto: String,
-    pub choice: String,
-    pub script: String,
-    pub script_parameter: String,
-    pub script_parameter2: String,
+// This is the only place where any YAML interaction should be happening.
+#[derive(Resource)]
+pub struct ChatDB(Vec<Value>);
+impl ChatDB {
+    pub fn load_from_str(&mut self, yaml_string: &str) -> Result<(), ()> {
+        let mut count = 0;
+        for document in serde_yaml::Deserializer::from_str(yaml_string) {
+            match Value::deserialize(document) {
+                Ok(yaml_data) => {
+                    if let Value::Sequence(yaml_sequence) = yaml_data {
+                        self.0.push(Value::Sequence(yaml_sequence));
+                        count += 1;
+                    }
+                    else {
+                        error!("Could not load YAML: {:?}", yaml_data);
+                    }
+                }
+                Err(error) => {
+                    dbg!(error);
+                    return Err(());
+                }
+            }
+        }
+        info!("Loaded {count} conversations");
+        return Ok(());
+    }
+
+    pub fn preprocess_includes(&mut self) {
+        let mut include_db: HashMap<String, Vec<Value>> = HashMap::new();
+        for sequence in &self.0 {
+            if let Some(vector) = sequence.as_sequence() {
+                if let Some(first_item) = vector.get(0) {
+                    if let Some(map) = first_item.as_mapping() {
+                        for (key, value) in map {
+                            if let (Some(key), Some(value)) = (key.as_str(), value.as_str()) {
+                                if key == TOKEN_CHAT {
+                                    include_db.insert(value.to_string(), vector.clone());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for mut sequence in self.0.iter_mut() {
+            ChatDB::preprocess_includes_recursively(&mut sequence, &include_db);
+        }
+    }
+
+    fn preprocess_includes_recursively(sequence: &mut Value, include_db: &HashMap<String, Vec<Value>>) {
+        let mut changes: Vec<(usize, String)> = Vec::new();
+        if let Some(vector) = sequence.as_sequence_mut() {
+            for (index, item) in vector.iter_mut().enumerate() {
+                match item {
+                    Value::Mapping(map) => {
+                        for (key, value) in map.iter_mut() {
+                            if let (Some(key), Some(value)) = (key.as_str(), value.as_str()) {
+                                if key == TOKEN_INCLUDE {
+                                    changes.push((index, value.to_string()));
+                                }
+                            }
+                            else if value.is_sequence() {
+                                ChatDB::preprocess_includes_recursively(value, include_db);
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            for (index, label) in changes {
+                vector.remove(index);
+                vector.splice(index..index, include_db[&label].iter().cloned());
+            }
+        }
+        return;
+    }
+
+    pub fn get_chat_by_id(&self, id: &String) -> Result<usize, String> {
+        let mut found: Option<usize> = None;
+        for (index, object_yaml) in self.0.iter().enumerate() {
+            if let Some(chat_id) = object_yaml[0][TOKEN_CHAT].as_str() {
+                if chat_id == id {
+                    if found.is_some() {
+                        return Err("Found multiple chats with the same id!".to_string());
+                    }
+                    found = Some(index);
+                }
+            }
+        }
+        if let Some(result) = found {
+            return Ok(result);
+        }
+        return Err(format!("No chat with the conversation ID `{id}` was found."));
+    }
+
+    // For a given Value, check whether it's a Value::Mapping and whether it
+    // contains a choice.  Mappings that will be detected as choices:
+    // - `{"What's up?": [...]}`
+    // - `{"What's up?": [...], "if": "value > 3"}`
+    // Not acceptable:
+    // - `"What's up?"`
+    // - `{"goto": "foo"}`
+    // Returns (choice text, sub-conversation branch, nowait flag)
+    fn search_choice(&self, yaml: Option<&Value>) -> Option<(String, Value, bool)> {
+        let non_choice_tokens = NON_CHOICE_TOKENS.to_vec();
+        let mut result: Option<(String, Value, bool)> = None;
+        let mut nowait = false;
+        if let Some(Value::Mapping(map)) = yaml {
+            for (key, value) in map {
+                if let Value::String(key) = key {
+                    if key == TOKEN_NOWAIT && value.as_bool() == Some(true) {
+                        nowait = true;
+                    }
+                    if non_choice_tokens.contains(&key.as_str()) {
+                        continue;
+                    }
+                    result = Some((key.into(), map[key].clone(), nowait));
+                }
+            }
+        }
+        return result;
+    }
+
+    fn search_label_recursively(&self, sequence: &Value, label: &String, mut pos: ChatPos) -> Option<ChatPos> {
+        if pos.len() > MAX_BRANCH_DEPTH {
+            return None;
+        }
+        if let Some(vector) = sequence.as_sequence() {
+            for (index, item) in vector.iter().enumerate() {
+                match item {
+                    Value::String(_) => {}
+                    Value::Mapping(map) => {
+                        for (key, value) in map {
+                            if let Some(key) = key.as_str() {
+                                if key == TOKEN_LABEL {
+                                    if value == label {
+                                        pos.push(index);
+                                        return Some(pos);
+                                    }
+                                }
+                            }
+                            if value.is_sequence() {
+                                pos.push(index);
+                                if let Some(result) = self.search_label_recursively(
+                                        value, label, pos.clone()) {
+                                    return Some(result)
+                                }
+                                pos.pop();
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+        return None;
+    }
+
+    fn search_label(&self, chat_id: usize, label: &String) -> Option<ChatPos> {
+        if label == TOKEN_GOTO_EXIT {
+            return Some(vec![]);
+        }
+        return self.search_label_recursively(&self.0[chat_id], label, vec![]);
+    }
+
+    // returns true if we reached the end of a branch and possibly popped the position stack
+    fn advance_pointer(&self, chat: &mut Chat) -> bool {
+        let len = chat.position.len();
+        if len == 0 {
+            return true; // out of bounds
+        }
+        chat.position[len - 1] += 1;
+
+        let mut popped = false;
+        let mut seek_past_dialog_choices = false;
+        while chat.position.len() > 0 {
+            match self.at(chat.id, &chat.position) {
+                None => {
+                    chat.position.pop();
+                    popped = true;
+                    seek_past_dialog_choices = true;
+                    if chat.position.len() > 0 {
+                        let index = chat.position.len() - 1;
+                        chat.position[index] += 1;
+                    }
+                },
+                Some(Value::Mapping(map)) => {
+                    if seek_past_dialog_choices && self.search_choice(Some(&Value::Mapping(map))).is_some() {
+                        // we just dropped out of a branch and ended up in a dialog
+                        // choice. let's seek past all the choices until we find
+                        // the next non-dialog-choice item.
+                        if chat.position.len() > 0 {
+                            let index = chat.position.len() - 1;
+                            chat.position[index] += 1;
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+                Some(_) => {
+                    break;
+                }
+            }
+        }
+        if chat.position.len() == 0 {
+            return true; // out of bounds
+        }
+        return popped;
+    }
+
+    // Returns the Value at the given ID/position, as-is.
+    // If it's a choice, it returns the entire {"choice text": [...]} mapping.
+    fn at(&self, id: usize, position: &Vec<usize>) -> Option<Value> {
+        if position.len() == 0 {
+            return None;
+        }
+        let mut result: Option<Value> = None;
+        let mut pointer: Option<Value> = Some(self.0[id].clone());
+        let mut next_pointer: Option<Value> = None;
+        for index in position {
+            if let Some(Value::Sequence(seq)) = &pointer {
+                let value = seq.get(*index);
+                match value {
+                    Some(Value::String(value_string)) => {
+                        result = Some(Value::String(value_string.into()));
+                    }
+                    Some(Value::Mapping(mapping)) => {
+                        if let Some((_choicetext, subconversation, _)) = self.search_choice(value) {
+                            result = Some(Value::Mapping(mapping.clone()));
+                            next_pointer = Some(subconversation);
+                        }
+                        else {
+                            result = Some(Value::Mapping(mapping.clone()));
+                        }
+                    }
+                    None => {
+                        return None; // Out of bounds.
+                    }
+                    _ => {
+                        error!("Could not handle YAML value {value:?}");
+                        return None;
+                    }
+                }
+                pointer = next_pointer;
+                next_pointer = None;
+            } else {
+                return None;
+            }
+        }
+        return result;
+    }
+
+    // Determines whether the item at the current position is "skippable".
+    // This means that we should process it right away to get to the correct
+    // position for finding the choices of a message.
+    // This includes flow control tokens like "goto", no-op tokens like "label",
+    // but not something with a side effect like "script", and especially not "if".
+    fn is_skippable(&self, chat: &mut Chat) -> bool {
+        let current_item = self.at(chat.id, &chat.position);
+        if current_item.is_none() {
+            return false;
+        }
+        if let Some(map) = current_item.unwrap().as_mapping() {
+            for key in map.keys() {
+                if let Some(key) = key.as_str() {
+                    if !SKIPPABLE_TOKENS.contains(&key) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            }
+            // It's a mapping that contains ONLY keys in SKIPPABLE_TOKENS.
+            return true;
+        }
+        return false;
+    }
+
+    fn process_yaml_entry(
+        &self,
+        chat: &mut Chat,
+        event: &mut EventWriter<ChatEvent>,
+    ) -> bool {
+        let current_item = self.at(chat.id, &chat.position);
+        let mut processed_a_choice = false;
+        match current_item {
+            Some(Value::String(message)) => {
+                event.send(ChatEvent::SpawnMessage(message.to_string(),
+                    hud::LogLevel::Chat, DEFAULT_SOUND.to_string()));
+            }
+            Some(Value::Mapping(map)) => {
+                let mut sound = DEFAULT_SOUND.to_string();
+
+                // Is this a dialog choice?
+                if let Some(_) = self.search_choice(Some(&Value::Mapping(map.clone()))) {
+                    processed_a_choice = true;
+                }
+
+                // We're going through the list of keys/values multiple times
+                // to ensure that dependencies for certain commands are available
+
+                // First pass
+                for (key, value) in &map {
+                    let key = key.as_str();
+                    match (key, value) {
+                        (Some(TOKEN_IF), _) => {} // TODO
+                        (Some(TOKEN_SOUND), Value::String(sound_name)) => {
+                            sound = sound_name.clone();
+                        }
+                        _ => {}
+                    }
+                }
+
+                // Second pass
+                for (key, value) in &map {
+                    let key = key.as_str();
+                    match (key, value) {
+                        (Some(TOKEN_MSG), Value::String(message)) => {
+                            event.send(ChatEvent::SpawnMessage(
+                                    message.to_string(), hud::LogLevel::Chat, sound.clone()));
+                        }
+                        (Some(TOKEN_SYSTEM), Value::String(message)) => {
+                            event.send(ChatEvent::SpawnMessage(
+                                    message.to_string(), hud::LogLevel::Info, sound.clone()));
+                        }
+                        (Some(TOKEN_WARN), Value::String(message)) => {
+                            event.send(ChatEvent::SpawnMessage(
+                                    message.to_string(), hud::LogLevel::Warning, sound.clone()));
+                        }
+                        (Some(TOKEN_SET), _) => {} // TODO
+                        _ => {}
+                    }
+                }
+
+                // Third pass
+                for (key, value) in &map {
+                    let key = key.as_str();
+                    match (key, value) {
+                        (Some(TOKEN_SLEEP), Value::Number(time)) => {
+                            if let Some(time_f64) = time.as_f64() {
+                                event.send(ChatEvent::Sleep(time_f64));
+                            }
+                        }
+                        (Some(TOKEN_GOTO), Value::String(label)) => {
+                            match self.search_label(chat.id, &label) {
+                                Some(pos) => {
+                                    chat.position = pos;
+                                }
+                                None => {
+                                    error!("Could not find goto label {label}!");
+                                }
+                            }
+                        }
+                        (Some(TOKEN_SCRIPT), Value::String(script)) => {
+                            event.send(ChatEvent::RunScript(script.clone()));
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            None => {
+                if chat.position.len() == 0 {
+                    event.send(ChatEvent::SpawnMessage("Disconnected.".to_string(),
+                        hud::LogLevel::Info, DEFAULT_SOUND.to_string()));
+                    event.send(ChatEvent::DespawnAllChats);
+                }
+            }
+            _ => {
+                error!("Can't handle YAML value {current_item:?}");
+            }
+        }
+        return processed_a_choice;
+    }
+
+    pub fn advance_chat(&self, chat: &mut Chat, event: &mut EventWriter<ChatEvent>) {
+        event.send(ChatEvent::DespawnAllChoices);
+
+        // Handle this entry in the chat list
+        let processed_a_choice: bool = self.process_yaml_entry(chat, event);
+
+        // Move on to next entry
+        self.advance_pointer(chat);
+
+        // Add the following choices, unless we ended up in the middle of a dialog
+        // choice list, and should just skip through to the next non-dialog-choice item
+        if !processed_a_choice {
+            // Skip/process some entries right away, to be able to fetch the correct choices
+            while self.is_skippable(chat) {
+                self.process_yaml_entry(chat, event);
+                self.advance_pointer(chat);
+            }
+
+            // Spawn choices until we reach a non-choice item or the end of the branch
+            let mut key: usize = 0;
+            let mut reached_end_of_branch = false;
+            while let Some((choice, _, nowait)) =
+                    self.search_choice(self.at(chat.id, &chat.position).as_ref()) {
+                if reached_end_of_branch {
+                    break;
+                }
+                let mut goto: Vec<usize> = chat.position.clone();
+                goto.push(0);
+                event.send(ChatEvent::SpawnChoice(choice, key, goto, nowait));
+                key += 1;
+                reached_end_of_branch = self.advance_pointer(chat);
+            }
+        }
+    }
 }
 
-#[derive(Component)]
-pub struct Chat {
-    pub id: String,
-    pub label: String,
-    pub timer: f64,
+pub fn load_chats(mut chatdb: ResMut<ChatDB>) {
+    for chat_yaml in CHATS {
+        if chatdb.load_from_str(chat_yaml).is_err() {
+            error!("Could not load chat definitions.  Validate files in `src/chats/` path.");
+        }
+    }
+    chatdb.preprocess_includes();
 }
 
-#[derive(Component)]
-pub struct ChoiceAvailable {
-    pub conv_id: String,
-    pub conv_label: String,
-    pub recipient: String,
-    pub text: String,
-}
-
-
-#[derive(Component)]
-#[derive(Clone)]
-pub struct Talker {
-    pub pronoun: String,
-    pub conv_id: String,
-}
-impl Default for Talker { fn default() -> Self { Self {
-    pronoun: "they/them".to_string(),
-    conv_id: "error".to_string(),
-}}}
-
 pub fn handle_new_conversations(
     mut commands: Commands,
     mut er_conv: EventReader<StartConversationEvent>,
     mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
-    q_conv: Query<&Chat>,
+    mut ew_chatevent: EventWriter<ChatEvent>,
+    chatdb: Res<ChatDB>,
+    q_chats: Query<&Chat>,
     time: Res<Time>,
 ) {
-    let label = "INIT";
     for event in er_conv.read() {
-        // check for existing chats with this id
-        let id = &event.talker.conv_id;
-        let chats: Vec<&Chat> = q_conv.iter().filter(|c| c.id == *id).collect();
-        if chats.len() > 0 {
+        if !q_chats.is_empty() {
             ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Ping));
-            continue;
+            return;
         }
+        match (*chatdb).get_chat_by_id(&event.talker.conv_id) {
+            Ok(chat_id) => {
+                let mut chat = Chat {
+                    id: chat_id,
+                    position: vec![0],
+                    timer: time.elapsed_seconds_f64(),
+                    talker: event.talker.clone(),
+                };
+                chatdb.advance_chat(&mut chat, &mut ew_chatevent);
+                commands.spawn((
+                    chat,
+                    world::DespawnOnPlayerDeath,
+                ));
+            }
+            Err(error) => {
+                error!("Error while looking for chat ID: {error}");
+            }
+        }
+    }
+}
 
-        // no existing chats yet, let's create a new one
-        commands.spawn((
-            Chat {
-                id: id.to_string(),
-                label: label.to_string(),
-                timer: time.elapsed_seconds_f64(),
-            },
-            world::DespawnOnPlayerDeath,
-        ));
-        break;
+pub fn handle_chat_timer(
+    time: Res<Time>,
+    chatdb: Res<ChatDB>,
+    mut q_chats: Query<&mut Chat>,
+    mut ew_chatevent: EventWriter<ChatEvent>,
+) {
+    let now = time.elapsed_seconds_f64();
+    for mut chat in &mut q_chats {
+        if now >= chat.timer {
+            chatdb.advance_chat(&mut chat, &mut ew_chatevent);
+        }
+    }
+}
+
+pub fn handle_chat_events(
+    mut commands: Commands,
+    mut er_chatevent: EventReader<ChatEvent>,
+    mut ew_chatscript: EventWriter<ChatScriptEvent>,
+    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
+    mut log: ResMut<hud::Log>,
+    q_choices: Query<Entity, With<Choice>>,
+    mut q_chats: Query<(Entity, &mut Chat)>,
+    time: Res<Time>,
+    settings: Res<settings::Settings>,
+) {
+    for event in er_chatevent.read() {
+        let now = time.elapsed_seconds_f64();
+        let chat_maybe = q_chats.get_single_mut();
+        if chat_maybe.is_err() {
+            return;
+        }
+        let (chat_entity, mut chat) = chat_maybe.unwrap();
+
+        match event {
+            ChatEvent::DespawnAllChoices => {
+                for entity in &q_choices {
+                    commands.entity(entity).despawn();
+                }
+            }
+            ChatEvent::DespawnAllChats => {
+                commands.entity(chat_entity).despawn();
+            }
+            ChatEvent::SpawnMessage(message, level, sound) => {
+                match level {
+                    hud::LogLevel::Chat => {
+                        log.chat(message.into(), chat.talker.name.clone().unwrap_or("".to_string()));
+                    }
+                    hud::LogLevel::Info | hud::LogLevel::Notice => {
+                        log.info(message.into());
+                    }
+                    hud::LogLevel::Warning => {
+                        log.warning(message.into());
+                    }
+                }
+                chat.timer = now + ((message.len() as f32).max(CHAT_SPEED_MIN_LEN) * TALKER_SPEED_FACTOR * chat.talker.talking_speed / settings.chat_speed) as f64;
+
+                let sfx = audio::str2sfx(sound);
+                ew_sfx.send(audio::PlaySfxEvent(sfx));
+            }
+            ChatEvent::SpawnChoice(replytext, key, goto, nowait) => {
+                commands.spawn((
+                    world::DespawnOnPlayerDeath,
+                    Choice {
+                        text: replytext.into(),
+                        key: *key,
+                        goto: goto.clone(),
+                    }
+                ));
+                if !nowait {
+                    chat.timer = now + CHOICE_TIMER / settings.chat_speed as f64;
+                }
+            }
+            ChatEvent::RunScript(script) => {
+                ew_chatscript.send(ChatScriptEvent(script.clone()));
+            }
+            ChatEvent::Sleep(sleep_duration) => {
+                chat.timer = now + sleep_duration;
+            }
+        }
     }
 }
 
 fn handle_reply_keys(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     settings: ResMut<settings::Settings>,
-    q_choices: Query<&ChoiceAvailable>,
-    mut evwriter_sendmsg: EventWriter<SendMessageEvent>,
+    q_choices: Query<&Choice>,
+    mut q_chats: Query<&mut Chat>,
+    //mut evwriter_sendmsg: EventWriter<SendMessageEvent>,
     mut evwriter_sfx: EventWriter<audio::PlaySfxEvent>,
+    time: Res<Time>,
 ) {
-    let mut selected_choice = 1;
+    let mut selected_choice: usize = 0;
     'outer: for key in settings.get_reply_keys() {
         if keyboard_input.just_pressed(key) {
-            let mut count = 1;
             for choice in &q_choices {
-                if count == selected_choice {
-                    evwriter_sfx.send(audio::PlaySfxEvent(audio::Sfx::Click));
-                    evwriter_sendmsg.send(SendMessageEvent {
-                        conv_id: choice.conv_id.clone(),
-                        conv_label: choice.conv_label.clone(),
-                        text: choice.text.clone(),
-                    });
+                if choice.key == selected_choice {
+                    if let Ok(mut chat) = q_chats.get_single_mut() {
+                        evwriter_sfx.send(audio::PlaySfxEvent(audio::Sfx::Click));
+                        chat.timer = time.elapsed_seconds_f64();
+                        chat.position = choice.goto.clone();
+                    }
                     break 'outer;
                 }
-                count += 1;
             }
         }
         selected_choice += 1;
     }
 }
 
-pub fn handle_send_messages(
-    mut commands: Commands,
-    mut er_sendmsg: EventReader<SendMessageEvent>,
-    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
-    mut ew_chatscript: EventWriter<ChatScriptEvent>,
-    mut q_conv: Query<(Entity, &mut Chat)>,
-    time: Res<Time>,
-    chat_branches: Query<&ChatBranch>,
-    mut log: ResMut<hud::Log>,
-) {
-    let now = time.elapsed_seconds_f64();
-
-    for event in er_sendmsg.read() {
-        for (entity, mut chat) in &mut q_conv {
-            if chat.id != event.conv_id {
-                continue;
-            }
-            if event.conv_label == "EXIT" {
-                info!("Despawning chat.");
-                commands.entity(entity).despawn();
-                continue;
-            }
-
-            let branches: Vec<&ChatBranch> = chat_branches.iter()
-                .filter(|branch| branch.id == event.conv_id
-                        && branch.label == event.conv_label
-                        && branch.choice == event.text)
-                .collect();
-            if branches.len() != 1 {
-                error!("Expected 1 branch with ID '{}', label '{}', choice '{}', but got {}! Aborting conversation.", event.conv_id, event.conv_label, event.text, branches.len());
-                continue;
-            }
-            let branch = branches[0];
-            // TODO despawn the choices
-
-            if !branch.reply.is_empty() {
-                match branch.level.as_str() {
-                    "chat" => log.chat(branch.reply.clone(), branch.name.clone()),
-                    "info" => log.info(branch.reply.clone()),
-                    "warn" => log.warning(branch.reply.clone()),
-                    _ => (),
-                }
-            }
-
-            chat.label = branch.goto.clone();
-            chat.timer = now + branch.delay;
-            if branch.sound != "" {
-                let sfx = audio::str2sfx(branch.sound.as_str());
-                ew_sfx.send(audio::PlaySfxEvent(sfx));
-            }
-            let choices: Vec<&ChatBranch> = chat_branches.iter()
-                .filter(|branch| branch.id == chat.id && branch.label == chat.label)
-                .collect();
-            for choice in choices {
-                if choice.choice.as_str() != hud::CHOICE_NONE {
-                    commands.spawn((
-                        ChoiceAvailable {
-                            conv_id: choice.id.clone(),
-                            conv_label: choice.label.clone(),
-                            recipient: choice.name.clone(),
-                            text: choice.choice.clone(),
-                        },
-                        world::DespawnOnPlayerDeath,
-                    ));
-                }
-            }
-            if !branch.script.is_empty() {
-                ew_chatscript.send(ChatScriptEvent {
-                    name: branch.script.clone(),
-                    param: branch.script_parameter.clone(),
-                    param2: branch.script_parameter2.clone(),
-                });
-            }
-        }
-        break; // let's only handle one of these per frame
-    }
-}
-
-pub fn handle_conversations(
-    mut commands: Commands,
-    mut log: ResMut<hud::Log>,
-    mut q_conv: Query<(Entity, &mut Chat)>,
-    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
-    mut ew_chatscript: EventWriter<ChatScriptEvent>,
-    time: Res<Time>,
-    chat_branches: Query<&ChatBranch>, // TODO: use Table for faster iteration?
-) {
-    let now = time.elapsed_seconds_f64();
-    for (entity, mut chat) in &mut q_conv {
-        if chat.label == "EXIT" {
-            info!("Despawning chat.");
-            commands.entity(entity).despawn();
-            continue;
-        }
-        if now < chat.timer {
-            continue;
-        }
-
-        let branches: Vec<&ChatBranch> = chat_branches.iter()
-            .filter(|branch| branch.id == chat.id
-                    && branch.label == chat.label
-                    && branch.choice == "")
-            .collect();
-        if branches.len() != 1 {
-            error!("Expected 1 branch with ID '{}' and label '{}', but got {}! Aborting conversation.", chat.id, chat.label, branches.len());
-            continue;
-        }
-        let branch = branches[0];
-
-        if !branch.reply.is_empty() {
-            match branch.level.as_str() {
-                "chat" => log.chat(branch.reply.clone(), branch.name.clone()),
-                "info" => log.info(branch.reply.clone()),
-                "warn" => log.warning(branch.reply.clone()),
-                _ => (),
-            }
-        }
-
-        if chat.label == "EXIT" {
-            // TODO: isn't this dead code?
-            continue;
-        }
-        chat.label = branch.goto.clone();
-        if branch.sound != "" {
-            let sfx = audio::str2sfx(branch.sound.as_str());
-            ew_sfx.send(audio::PlaySfxEvent(sfx));
-        }
-        chat.timer = now + branch.delay;
-
-        let choices: Vec<&ChatBranch> = chat_branches.iter()
-            .filter(|branch| branch.id == chat.id && branch.label == chat.label)
-            .collect();
-        for choice in choices {
-            if choice.choice.as_str() != hud::CHOICE_NONE {
-                commands.spawn((
-                    ChoiceAvailable {
-                        conv_id: choice.id.clone(),
-                        conv_label: choice.label.clone(),
-                        recipient: choice.name.clone(),
-                        text: choice.choice.clone(),
-                    },
-                    world::DespawnOnPlayerDeath,
-                ));
-            }
-        }
-
-        if !branch.script.is_empty() {
-            ew_chatscript.send(ChatScriptEvent {
-                name: branch.script.clone(),
-                param: branch.script_parameter.clone(),
-                param2: branch.script_parameter2.clone(),
-            });
-        }
-    }
-}
-
 pub fn handle_chat_scripts(
     mut er_chatscript: EventReader<ChatScriptEvent>,
     mut q_actor: Query<(&mut actor::Actor, &mut actor::Suit), Without<actor::Player>>,
@@ -308,20 +692,32 @@ pub fn handle_chat_scripts(
     mut ew_effect: EventWriter<effects::SpawnEffectEvent>,
 ) {
     for script in er_chatscript.read() {
-        match script.name.as_str() {
-            "refilloxygen" => if let Ok(mut amount) = script.param.parse::<f32>() {
+        // Parse the script string
+        let mut parts = script.0.split_whitespace();
+        let name = parts.next();
+        if name.is_none() {
+            error!("ChatScriptEvent should not contain a script name and its parameters, got empty String");
+            return;
+        }
+        let name = name.unwrap();
+        let param1 = parts.next().unwrap_or("");
+        let param2 = parts.next().unwrap_or("");
+
+        // Process the script
+        match name {
+            "refilloxygen" => if let Ok(mut amount) = param1.to_string().parse::<f32>() {
                 for (_, mut suit, _) in q_player.iter_mut() {
-                    if script.param2.is_empty() {
+                    if param2.is_empty() {
                         suit.oxygen = (suit.oxygen + amount).clamp(0.0, suit.oxygen_max);
                     }
                     else {
                         let mut found_other = false;
-                        info!("param2={}", script.param2);
+                        info!("param2={}", param2);
                         for (other_actor, mut other_suit) in q_actor.iter_mut() {
                             if !other_actor.id.is_empty() {
                                 info!("ID={}", other_actor.id);
                             }
-                            if other_actor.id == script.param2 {
+                            if other_actor.id == param2 {
                                 found_other = true;
                                 amount = amount
                                     .clamp(0.0, other_suit.oxygen)
@@ -332,33 +728,33 @@ pub fn handle_chat_scripts(
                             }
                         }
                         if !found_other {
-                            error!("Script error: could not find actor with ID `{}`", script.param2);
+                            error!("Script error: could not find actor with ID `{}`", param2);
                         }
                     }
                 }
             } else {
-                error!("Invalid parameter for command `{}`: `{}`", script.name, script.param);
+                error!("Invalid parameter for command `{}`: `{}`", name, param1);
             }
             "cryotrip" => {
-                if script.param.is_empty() {
+                if param1.is_empty() {
                     error!("Chat script cryotrip needs a parameter");
                 }
                 else {
                     if let Ok((mut pos, mut v)) = q_playercam.get_single_mut() {
-                        if script.param == "oscillation".to_string() {
+                        if param1 == "oscillation".to_string() {
                             *pos = Position(DVec3::new(147e6, 165e6, 336e6));
                             v.0 = DVec3::ZERO;
                         }
-                        else if script.param == "metisprime".to_string() {
+                        else if param1 == "metisprime".to_string() {
                             *pos = Position(DVec3::new(27643e3, -47e3, -124434e3));
                             v.0 = DVec3::ZERO;
                         }
-                        else if script.param == "serenity".to_string() {
+                        else if param1 == "serenity".to_string() {
                             *pos = Position(DVec3::new(-121095e3, 582e3, -190816e3));
                             v.0 = DVec3::ZERO;
                         }
                         else {
-                            error!("Invalid destination for cryotrip chat script: '{}'", script.param);
+                            error!("Invalid destination for cryotrip chat script: '{}'", param1);
                         }
                     }
                     if let Ok((_, mut suit, mut gforce)) = q_player.get_single_mut() {
@@ -379,28 +775,8 @@ pub fn handle_chat_scripts(
                 });
             }
             _ => {
-                let script_name = &script.name;
-                error!("Error, undefined chat script {script_name}");
+                error!("Error, undefined chat script {name}");
             }
         }
     }
 }
-
-fn despawn_old_choices(
-    mut commands: Commands,
-    q_conv: Query<&Chat>,
-    q_choices: Query<(Entity, &ChoiceAvailable)>,
-) {
-    let chats: Vec<&Chat> = q_conv.iter().collect();
-    'outer: for (entity, choice) in &q_choices {
-        // Let's see if this choice still has a chat in the appropriate state
-        for chat in &chats {
-            if choice.conv_id == chat.id && choice.conv_label == chat.label {
-                continue 'outer;
-            }
-        }
-
-        // Despawn the choice, since no matching chat was found
-        commands.entity(entity).despawn();
-    }
-}
diff --git a/src/chats/serenity.yaml b/src/chats/serenity.yaml
new file mode 100644
index 0000000..aed97fd
--- /dev/null
+++ b/src/chats/serenity.yaml
@@ -0,0 +1,167 @@
+- chat: Drifter
+- system: "Error: No response"
+- system: No life signs detected
+- Damn, it's gotta be moldy in that suit. How long has it been drifting?:
+- Harvest some oxygen:
+  - script: refilloxygen 1 Drifter
+
+
+---
+
+
+- chat: SubduedClippy
+- At your service!
+
+
+---
+
+
+- chat: Icarus
+- Oh hey, you're awake!
+- I found you drifting out cold, and thought, I better watch over you.
+- Took us here behind that moonlet, to shield you from the micros.
+- Thank you!:
+  - label: thx
+  - No worries. Folks are stretched thin around this corner, we gotta watch out for each other.
+  - How are you feeling?
+  - goto: howru
+- I didn't ask for this.:
+  - label: didntask
+  - "Sure, 'cause you were unconscious. I just did what felt right. Is there a problem?"
+  - Nevermind. Thank you.:
+    - goto: thx
+  - Leave me alone!:
+    - goto: EXIT
+- Micros? What's that?:
+  - Micrometeorites. Those tiny 混蛋 that fly right through you, leaving holes in your suit. And your body.
+  - Ouch! Thank you so much.:
+    - goto: thx
+  - Whatever... I didn't ask for this.:
+    - goto: didntask
+
+
+- How are you feeling?
+- label: howru
+- I feel quite cozy, this space suit feels like a second skin.:
+  - set: friends
+  - Hah, it does, doesn't it?
+  - But take care, your suit seems to be leaking. I'd patch it up if I were you.
+  - I'm all out of SuitPatch™ SuperGlue™ right now, otherwise i'd share.
+  - Can I help you with anything else, maybe?
+- I got this apocalyptic headache...:
+  - set: friends
+  - Heh, probably related to why you were passed out.
+  - Go easy on yourself, I'm sure things will turn for the better.
+  - Meanwhile, can I help you with anything?
+- I... don't know, I'm pretty disoriented.:
+  - set: friends
+  - Oh no. Do you need a lowdown on reality?
+- I just want to be alone right now:
+  - Oh, sure. Ping me if you need anything. I'll go back to playing my VR game.
+  - goto: EXIT
+
+
+- label: help
+- Where are we?:
+  - This is space, my friend.
+  - That massive crescent over there, that's Juptiter.
+  - We're about 150,000km away from its surface, on the very outside of it's rings.
+  - This area is called the Thebe gossamer ring.
+  - The moon Thebe is actually pretty close right now, flinging all those micros at us.
+  - Micros? What's that?:
+    - Micrometeorites. Those tiny 混蛋 that fly right through you, leaving holes in your suit. And your body.
+  - goto: help
+- What year is this?:
+  - Oh, is your Augmented Reality deactivated?
+  - Push the TAB button, your space suit's AR will show you the date and time.
+  - goto: help
+- Why am I here?:
+  - That's a very philosophical question.
+  - I don't know.
+  - It's probably related to the choices you made in your life so far.
+  - goto: help
+- What should I do?:
+  - Ah, that's the beauty of life.
+  - You can just do whatever you want.
+  - So long as you have the means, and respect people's boundaries.
+  - I'm here mostly for the view and the peace.
+  - Just look at Jupiter, it's mesmerizing, isn't it?
+  - So far away from everything, nobody expects anything from you.
+  - If you want, you can take my sports racing capsule MeteorAceGT™ for a ride. It's right over there.
+  - It rides like a punch in the face, don't hurt yourself, ok?
+  - You're too kind!:
+    - Ah, don't mention it!
+  - There's also a half-decent pizza restaurant over there, look for the neon sign.
+  - goto: help
+- Do you have some money for me?:
+  - Huh? What is money?
+  - Currency? Flat round things that you can exchange for goods and services?:
+    - Uhm... are you talking about pizza?
+    - I don't have any pizza with me right now.
+    - But there's a pizza place right over there, look for the neon sign.
+    - goto: help
+  - Well, anyway, need anything else?
+  - goto: help
+- I think I'm good for now:
+  - goto: chocolate
+- Well, I hope you're ok.
+
+
+- label: chocolate
+- I got some left-over instant hot chocolate, would you like some?
+- Oh yes! Please!:
+  - Here you go, my friend!
+  - system: Received 1x ChuggaChug™ Instant Hot Chocolate
+  - goto: pizzaplace
+- No, thank you.:
+- Well. I think I'll go back to playing my VR game. Ping me if you need anything.
+- label: pizzaplace
+- Oh and make sure to check out the pizza place!
+- Will do, bye!:
+
+
+---
+
+
+- chat: SpacePizzaChef
+- Welcome to Space Pizza™, best pizza around the rings!
+- Great to see a customer, we don't get many lately
+- Would you like to order today's special?
+- label: offer
+- What's the special?:
+  - Suspicious Spacefunghi
+  - With free pineapple imitation
+  - Our pizza smoothies are freshly blended every day
+  - Wait... pizza smoothie?:
+    - Huh? Of course, smoothie! How else do you want to get that pizza down your spacesuit feeding tube?
+  - An emulsion of deliciousness!
+  - I think I'll pass...:
+    - Your loss, mate
+    - goto: EXIT
+- Wh... what's a pizzeria doing here?:
+  - Hah, beautiful, right? I carved it out this asteroid myself!
+  - You know how much work it was to neutralize the rotation of the asteroid, so my valued customers don't bang against the walls while drinking my pizza?
+  - Now would you like today's special or not?
+  - goto: offer
+- My head hurts, my suit leaks, I think I'm dying...:
+  - Seriously? Let me have a look. Just press the 'Grant Access' button please.
+  - "[GRANT ACCESS TO SPACESUIT WIFI]":
+    - label: hack
+    - warn: MALWARE DETECTED
+    - warn: BITCOIN MINER DETECTED
+    - nowait: true
+      Hey, what are you doing with me?:
+      - Just checking your systems, hang on tight
+    - Yeah, suit's fucked, I'd look out for a repair shop
+    - Anyway, wanna order today's special?
+    - goto: offer
+  - "[DENY ACCESS TO SPACESUIT WIFI]":
+    - Oh come on, do you want my help or not?
+    - "[GRANT ACCESS TO SPACESUIT WIFI]":
+      - goto: hack
+    - "[DENY ACCESS TO SPACESUIT WIFI]":
+      - Great, the first customer in ages, and they're brain damaged...
+    - Fuck off!:
+      - Great, the first customer in ages, and they're brain damaged...
+    - goto: EXIT
+- Hey, are you still there? Is this a prank?
diff --git a/src/chats/startrans.yaml b/src/chats/startrans.yaml
new file mode 100644
index 0000000..d660135
--- /dev/null
+++ b/src/chats/startrans.yaml
@@ -0,0 +1,88 @@
+- chat: NPCinCryoStasis
+- system: "Error: No response"
+- system: Lifeform in cryostasis detected
+
+
+---
+
+
+- chat: ClippyTransSerenity
+- Welcome at StarTrans Cargo Services!  You have reached Serenity Station.
+- "Ready for a trip?  Available bus stops: Oscillation Station, Metis Prime Station"
+- set: busstop serenity
+- label: startransbusstop
+- include: BusStops
+- label: interesting
+- Serenity Station is famous for the best pizza across the Jovian Rings.
+- Look for the neon sign of the pizzeria nearby.
+
+
+---
+
+
+- chat: ClippyTransMetis
+- Welcome at StarTrans Cargo Services!  You have reached Metis Prime Station.
+- "Ready for a trip?  Available bus stops: Oscillation Station, Serenity Station"
+- set: busstop metis
+- label: startransbusstop
+- include: BusStops
+- label: interesting
+- This area is an industrial paradise for asteroid miners.
+- Though it has been recently abandoned due to the excessive particle radiation.
+- I advise you to minimize the duration of your stay here.
+
+
+---
+
+
+- chat: ClippyTransOscillation
+- Welcome at StarTrans Cargo Services!  You have reached Oscillation Station.
+- "Ready for a trip?  Available bus stops: Serenity Station, Metis Prime Station"
+- set: busstop oscillation
+- label: startransbusstop
+- include: BusStops
+- label: interesting
+- The main attraction around here is the gorgeous view onto Jupiter from far up ahead.
+
+
+---
+
+
+- chat: BusStops
+- Bus stop?! How does this work?:
+  - StarTrans Cargo Services is the most convenient way to travel the vast distances of space.
+  - Just activate your suit's built-in cryostasis. A StarTrans carrier will pick you up and you will wake up at your destination in the blink of an eye.
+  - Of course we will supply you with free oxygen and ensure your safety.
+  - goto: startransbusstop
+- Can I take a spacecraft with me?:
+  - Absolutely.
+  - goto: startransbusstop
+- if: busstop != "oscillation"
+  Take me to Oscillation Station, please.:
+  - StarTrans wishes you a pleasant journey.
+  - script: cryofadeout
+  - sleep: 5
+  - script: cryotrip oscillation
+  - goto: EXIT
+- if: busstop != "metis"
+  Take me to Metis Prime Station, please.:
+  - StarTrans wishes you a pleasant journey.
+  - script: cryofadeout
+  - sleep: 5
+  - script: cryotrip metisprime
+  - goto: EXIT
+- if: busstop != "serenity"
+  Take me to Serenity Station, please.:
+  - StarTrans wishes you a pleasant journey.
+  - script: cryofadeout
+  - sleep: 5
+  - script: cryotrip serenity
+  - goto: EXIT
+- Can you please fill up my oxygen tank without taking me anywhere?:
+  - Of course, you can count on StarTrans!
+  - script: refilloxygen 1000
+- Is there anything interesting to do around here?:
+  - goto: interesting
+- No, thank you.:
+- Feel free to come back any time.
+- goto: EXIT
diff --git a/src/commands.rs b/src/commands.rs
index b58ada4..c8148d0 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -22,7 +22,6 @@ impl Plugin for CommandsPlugin {
 #[derive(PartialEq, Clone)]
 enum DefClass {
     Actor,
-    Chat,
     None,
 }
 
@@ -69,18 +68,18 @@ struct ParserState {
     light_color: Option<Color>,
     ar_model: Option<String>,
 
-    // Chat fields
-    delay: f64,
-    text: String,
-    level: String,
-    label: String,
-    goto: String,
-    is_choice: bool,
-    stores_item: bool,
-    script: String,
-    script_parameter: String,
-    script_parameter2: String,
-    sound: Option<String>,
+//    // Chat fields
+//    delay: f64,
+//    text: String,
+//    level: String,
+//    label: String,
+//    goto: String,
+//    is_choice: bool,
+//    stores_item: bool,
+//    script: String,
+//    script_parameter: String,
+//    script_parameter2: String,
+//    sound: Option<String>,
 }
 impl Default for ParserState {
     fn default() -> Self {
@@ -125,50 +124,50 @@ impl Default for ParserState {
             light_color: None,
             ar_model: None,
 
-            delay: 0.0,
-            text: "".to_string(),
-            level: "chat".to_string(),
-            label: "".to_string(),
-            goto: "".to_string(),
-            is_choice: false,
-            stores_item: false,
-            script: "".to_string(),
-            script_parameter: "".to_string(),
-            script_parameter2: "".to_string(),
-            sound: Some("chat".to_string()),
+//            delay: 0.0,
+//            text: "".to_string(),
+//            level: "chat".to_string(),
+//            label: "".to_string(),
+//            goto: "".to_string(),
+//            is_choice: false,
+//            stores_item: false,
+//            script: "".to_string(),
+//            script_parameter: "".to_string(),
+//            script_parameter2: "".to_string(),
+//            sound: Some("chat".to_string()),
         }
     }
 }
 impl ParserState {
-    fn reset_message(&mut self) {
-        let default = ParserState::default();
-        self.label = default.label;
-        self.delay = default.delay;
-        self.goto = default.goto;
-        self.level = default.level;
-        self.text = default.text;
-        self.is_choice = default.is_choice;
-        self.script = default.script;
-        self.script_parameter = default.script_parameter;
-        self.script_parameter2 = default.script_parameter2;
-        self.sound = default.sound;
-    }
-    fn as_chatbranch(&self) -> chat::ChatBranch {
-        return chat::ChatBranch {
-            id: self.chat.clone(),
-            name: self.name.clone().unwrap_or("".to_string()),
-            label: self.label.clone(),
-            delay: self.delay.clone(),
-            sound: if self.is_choice || self.sound.is_none() { "".to_string() } else { "chat".to_string() },
-            level: self.level.clone(),
-            reply: if self.is_choice { "".to_string() } else { self.text.clone() },
-            choice: if self.is_choice { self.text.clone() } else { "".to_string() },
-            goto: self.goto.clone(),
-            script: self.script.clone(),
-            script_parameter: self.script_parameter.clone(),
-            script_parameter2: self.script_parameter2.clone(),
-        }
-    }
+//    fn reset_message(&mut self) {
+//        let default = ParserState::default();
+//        self.label = default.label;
+//        self.delay = default.delay;
+//        self.goto = default.goto;
+//        self.level = default.level;
+//        self.text = default.text;
+//        self.is_choice = default.is_choice;
+//        self.script = default.script;
+//        self.script_parameter = default.script_parameter;
+//        self.script_parameter2 = default.script_parameter2;
+//        self.sound = default.sound;
+//    }
+//    fn as_chatbranch(&self) -> chat::ChatBranch {
+//        return chat::ChatBranch {
+//            id: self.chat.clone(),
+//            name: self.name.clone().unwrap_or("".to_string()),
+//            label: self.label.clone(),
+//            delay: self.delay.clone(),
+//            sound: if self.is_choice || self.sound.is_none() { "".to_string() } else { "chat".to_string() },
+//            level: self.level.clone(),
+//            reply: if self.is_choice { "".to_string() } else { self.text.clone() },
+//            choice: if self.is_choice { self.text.clone() } else { "".to_string() },
+//            goto: self.goto.clone(),
+//            script: self.script.clone(),
+//            script_parameter: self.script_parameter.clone(),
+//            script_parameter2: self.script_parameter2.clone(),
+//        }
+//    }
 }
 
 pub fn load_defs(
@@ -217,6 +216,11 @@ pub fn load_defs(
         }
 
         match parts.as_slice() {
+            ["name", name] => {
+                debug!("Registering name: {}", name);
+                state.name = Some(name.to_string());
+            }
+
             // Parsing actors
             ["actor", x, y, z, model] => {
                 ew_spawn.send(SpawnEvent(state));
@@ -468,106 +472,102 @@ pub fn load_defs(
             }
 
             // Parsing chats
-            ["chat", chat_name] => {
-                debug!("Registering chat: {}", chat_name);
-                ew_spawn.send(SpawnEvent(state));
-                state = ParserState::default();
-                state.class = DefClass::Chat;
-                state.chat = chat_name.to_string();
-            }
-            ["name", name] => {
-                debug!("Registering name: {}", name);
-                state.name = Some(name.to_string());
-            }
-            ["msg", sleep, text] => {
-                debug!("Registering message (sleep={}): {}", sleep, text);
-                ew_spawn.send(SpawnEvent(state.clone()));
-                if let Ok(sleep_float) = sleep.parse::<f64>() {
-                    state.delay = sleep_float;
-                    state.text = text.to_string();
-                    state.stores_item = true;
-                    state.is_choice = false;
-                } else {
-                    error!("The 'sleep' value for this message is not a float: {}", line);
-                    continue;
-                }
-            }
-            ["msg", sleep, label, goto, text] => {
-                debug!("Registering message (sleep={}): {}", sleep, text);
-                ew_spawn.send(SpawnEvent(state.clone()));
-                state.reset_message();
-                if let Ok(sleep_float) = sleep.parse::<f64>() {
-                    state.delay = sleep_float;
-                    state.text = text.to_string();
-                    state.stores_item = true;
-                    state.is_choice = false;
-                    state.goto = goto.to_string();
-                    state.label = label.to_string();
-                } else {
-                    error!("The 'sleep' value for this message is not a float: {}", line);
-                    continue;
-                }
-            }
-            ["choice", sleep, text] => {
-                debug!("Registering choice (sleep={}): {}", sleep, text);
-                ew_spawn.send(SpawnEvent(state.clone()));
-                state.reset_message();
-                if let Ok(sleep_float) = sleep.parse::<f64>() {
-                    state.delay = sleep_float;
-                    state.text = text.to_string();
-                    state.stores_item = true;
-                    state.is_choice = true;
-                } else {
-                    error!("The 'sleep' value for this message is not a float: {}", line);
-                    continue;
-                }
-            }
-            ["choice", sleep, label, goto, text] => {
-                debug!("Registering choice (sleep={}): {}", sleep, text);
-                ew_spawn.send(SpawnEvent(state.clone()));
-                state.reset_message();
-                if let Ok(sleep_float) = sleep.parse::<f64>() {
-                    state.delay = sleep_float;
-                    state.text = text.to_string();
-                    state.stores_item = true;
-                    state.is_choice = true;
-                    state.goto = goto.to_string();
-                    state.label = label.to_string();
-                } else {
-                    error!("The 'sleep' value for this message is not a float: {}", line);
-                    continue;
-                }
-            }
-            ["goto", label] => {
-                debug!("Registering goto: {}", label);
-                state.goto = label.to_string();
-            }
-            ["label", label] => {
-                debug!("Registering label: {}", label);
-                state.label = label.to_string();
-            }
-            ["lvl", level] => {
-                debug!("Registering level: {}", level);
-                state.level = level.to_string();
-            }
-            ["script", scriptname] => {
-                state.script = scriptname.to_string();
-                state.script_parameter = "".to_string();
-                state.script_parameter2 = "".to_string();
-            }
-            ["script", scriptname, parameter] => {
-                state.script = scriptname.to_string();
-                state.script_parameter = parameter.to_string();
-                state.script_parameter2 = "".to_string();
-            }
-            ["script", scriptname, parameter, parameter2] => {
-                state.script = scriptname.to_string();
-                state.script_parameter = parameter.to_string();
-                state.script_parameter2 = parameter2.to_string();
-            }
-            ["sound", "none"] => {
-                state.sound = None;
-            }
+//            ["chat", chat_name] => {
+//                debug!("Registering chat: {}", chat_name);
+//                ew_spawn.send(SpawnEvent(state));
+//                state = ParserState::default();
+//                state.class = DefClass::Chat;
+//                state.chat = chat_name.to_string();
+//            }
+//            ["msg", sleep, text] => {
+//                debug!("Registering message (sleep={}): {}", sleep, text);
+//                ew_spawn.send(SpawnEvent(state.clone()));
+//                if let Ok(sleep_float) = sleep.parse::<f64>() {
+//                    state.delay = sleep_float;
+//                    state.text = text.to_string();
+//                    state.stores_item = true;
+//                    state.is_choice = false;
+//                } else {
+//                    error!("The 'sleep' value for this message is not a float: {}", line);
+//                    continue;
+//                }
+//            }
+//            ["msg", sleep, label, goto, text] => {
+//                debug!("Registering message (sleep={}): {}", sleep, text);
+//                ew_spawn.send(SpawnEvent(state.clone()));
+//                state.reset_message();
+//                if let Ok(sleep_float) = sleep.parse::<f64>() {
+//                    state.delay = sleep_float;
+//                    state.text = text.to_string();
+//                    state.stores_item = true;
+//                    state.is_choice = false;
+//                    state.goto = goto.to_string();
+//                    state.label = label.to_string();
+//                } else {
+//                    error!("The 'sleep' value for this message is not a float: {}", line);
+//                    continue;
+//                }
+//            }
+//            ["choice", sleep, text] => {
+//                debug!("Registering choice (sleep={}): {}", sleep, text);
+//                ew_spawn.send(SpawnEvent(state.clone()));
+//                state.reset_message();
+//                if let Ok(sleep_float) = sleep.parse::<f64>() {
+//                    state.delay = sleep_float;
+//                    state.text = text.to_string();
+//                    state.stores_item = true;
+//                    state.is_choice = true;
+//                } else {
+//                    error!("The 'sleep' value for this message is not a float: {}", line);
+//                    continue;
+//                }
+//            }
+//            ["choice", sleep, label, goto, text] => {
+//                debug!("Registering choice (sleep={}): {}", sleep, text);
+//                ew_spawn.send(SpawnEvent(state.clone()));
+//                state.reset_message();
+//                if let Ok(sleep_float) = sleep.parse::<f64>() {
+//                    state.delay = sleep_float;
+//                    state.text = text.to_string();
+//                    state.stores_item = true;
+//                    state.is_choice = true;
+//                    state.goto = goto.to_string();
+//                    state.label = label.to_string();
+//                } else {
+//                    error!("The 'sleep' value for this message is not a float: {}", line);
+//                    continue;
+//                }
+//            }
+//            ["goto", label] => {
+//                debug!("Registering goto: {}", label);
+//                state.goto = label.to_string();
+//            }
+//            ["label", label] => {
+//                debug!("Registering label: {}", label);
+//                state.label = label.to_string();
+//            }
+//            ["lvl", level] => {
+//                debug!("Registering level: {}", level);
+//                state.level = level.to_string();
+//            }
+//            ["script", scriptname] => {
+//                state.script = scriptname.to_string();
+//                state.script_parameter = "".to_string();
+//                state.script_parameter2 = "".to_string();
+//            }
+//            ["script", scriptname, parameter] => {
+//                state.script = scriptname.to_string();
+//                state.script_parameter = parameter.to_string();
+//                state.script_parameter2 = "".to_string();
+//            }
+//            ["script", scriptname, parameter, parameter2] => {
+//                state.script = scriptname.to_string();
+//                state.script_parameter = parameter.to_string();
+//                state.script_parameter2 = parameter2.to_string();
+//            }
+//            ["sound", "none"] => {
+//                state.sound = None;
+//            }
             _ => {
                 error!("No match for [{}]", parts.join(","));
             }
@@ -585,13 +585,7 @@ fn spawn_entities(
 ) {
     for state_wrapper in er_spawn.read() {
         let state = &state_wrapper.0;
-        if state.class == DefClass::Chat {
-            if state.stores_item {
-                let mut chat = commands.spawn(state.as_chatbranch());
-                chat.insert(world::DespawnOnPlayerDeath);
-            }
-        }
-        else if state.class == DefClass::Actor {
+        if state.class == DefClass::Actor {
             let actor_entity;
             {
             let mut actor = commands.spawn_empty();
@@ -699,7 +693,9 @@ fn spawn_entities(
             if !state.chat.is_empty() {
                 actor.insert(chat::Talker {
                     conv_id: state.chat.clone(),
-                    ..default()
+                    name: state.name.clone(),
+                    pronoun: Some(state.pronoun.clone()),
+                    talking_speed: 1.0,
                 });
             }
             if state.is_vehicle {
diff --git a/src/defs.txt b/src/defs.txt
index d0d99ba..df4a8cd 100644
--- a/src/defs.txt
+++ b/src/defs.txt
@@ -179,15 +179,12 @@ actor -3300 10 0 pizzeria
         thrust 15 6 3 400 0.5
         rotationy -0.5
         scale 3
-        chatid pizzaclippy
-        chat pizzaclippy
-            name "Clippy™ Convenience Companion"
-            msg 4 INIT EXIT "At your service!"
+        chatid SubduedClippy
 
     actor -35 0 0 suit
         relativeto pizzeria
         name "Space Pizza™"
-        chatid pizzeria
+        chatid SpacePizzaChef
         armodel suit_ar_chefhat
         alive yes
         scale 2
@@ -198,55 +195,11 @@ actor -3300 10 0 pizzeria
         rotationy 1
         angularmomentum 0 0 0
         pronoun he
-        chat pizzeria
-            name "Space Pizza™"
-            msg 4 INIT cool "Welcome to Space Pizza™, best pizza around the rings!"
-            msg 4 cool order "Great to see a customer, we don't get many lately"
-            msg 50 order special "Would you like to order today's special?"
-            choice 3 special whatsthespecial "What's the special?"
-                msg 4 whatsthespecial pineapple "Suspicious Spacefunghi"
-                msg 4 pineapple smoothie "With free pineapple imitation"
-                msg 7 smoothie tube "Our pizza smoothies are freshly blended every day"
-                choice 3 tube wtftube "Wait... pizza smoothie?"
-                    msg 6 wtftube anyway "Huh? Of course, smoothie! How else do you want to get that pizza down your spacesuit feeding tube?"
-                    msg 6 anyway pass "An emulsion of deliciousness!"
-                msg 30 tube pass "Deliciousness for your spacesuit feeding tube!"
-                choice 3 pass yourloss "I think I'll pass..."
-                    msg 3 yourloss end "Your loss, mate"
-                msg 3 pass prank "Hey? Are you still there?"
-            choice 3 special carved "Wh... what's a pizzeria doing here?"
-                msg 6 carved work "Hah, beautiful, right? I carved it out this asteroid myself!"
-                msg 7 work nowwannaorder "You know how much work it was to neutralize the rotation of the asteroid, so my valued customers don't bang against the walls while drinking my pizza?"
-                msg 20 nowwannaorder special "Now would you like today's special or not?"
-            choice 3 special ohno "My head hurts, my suit leaks, I think I'm dying..."
-                msg 20 ohno pressok "Seriously? Let me have a look. Just press the 'Grant Access' button please."
-                choice 3 pressok virus "[GRANT ACCESS TO SPACESUIT WIFI]"
-                    msg 3 virus bitcoin "MALWARE DETECTED"
-                        lvl warn
-                    msg 6 bitcoin wtf "BITCOIN MINER DETECTED"
-                        lvl warn
-                    choice 5 wtf justchecking "Hey, what are you doing with me?"
-                        msg 6 justchecking suitfucked "Just checking your systems, hang on tight"
-                        msg 5 suitfucked wtfanyway "Yeah, suit's fucked, I'd look out for a repair shop"
-                    msg 5 wtf wtfanyway "Yeah, suit's fucked, I'd look out for a repair shop"
-                    msg 5 wtfanyway special "Anyway, wanna order today's special?"
-                choice 3 pressok deny "[DENY ACCESS TO SPACESUIT WIFI]"
-                    msg 5 deny pressok2 "Oh come on, do you want my help or not?"
-                    choice 3 pressok2 virus "[GRANT ACCESS TO SPACESUIT WIFI]"
-                    choice 3 pressok2 deny2 "[DENY ACCESS TO SPACESUIT WIFI]"
-                    choice 3 pressok2 deny2 "Fuck off!"
-                        msg 2 deny2 end "Great, the first customer in ages, and they're brain damaged..."
-                    msg 3 pressok2 prank "Hey? Are you still there?"
-                msg 3 pressok prank "Hey? Are you still there?"
-            msg 3 special prank "Hey? Are you still there?"
-            msg 4 prank end "This a prank?"
-            msg 0 end EXIT "Disconnected."
-                lvl info
 
 actor 60 -15 -40 suit
     relativeto player
     name Icarus
-    chatid hi_icarus
+    chatid Icarus
     alive yes
     scale 2
     collider capsule 1 0.5
@@ -257,109 +210,15 @@ actor 60 -15 -40 suit
     wants maxrotation 0.5
     wants maxvelocity 0
     pronoun it
-    chat hi_icarus
-        name Icarus
-        msg 4 INIT hi1 "Oh hey, you're awake!"
-        msg 6 hi1 hi2 "I found you drifting out cold, and thought, I better watch over you."
-        msg 40 hi2 hireply "Took us here behind that moonlet, to shield you from the micros."
-        choice 1 hireply thx "Thank you!"
-            msg 6 thx feeling "No worries. Folks are stretched thin around this corner, we gotta watch out for each other."
-            msg 40 feeling howru "How are you feeling?"
-        choice 1 hireply didntask "Eh... I didn't ask for this."
-            msg 6 didntask problem "Sure, 'cause you were unconscious. I just did what felt right. Is there a problem?"
-            choice 1 problem thx "Nevermind. Thank you."
-            choice 1 problem end "Leave me alone!"
-        choice 1 hireply micros "Micros? What's that?"
-            msg 40 micros microsexplained "Micrometeorites. Those tiny 混蛋 that fly right through you, leaving holes in your suit. And your body."
-            choice 1 microsexplained thx "Ouch! Thank you so much."
-            choice 1 microsexplained didntask "Whatever... I didn't ask for this."
-            msg 40 microsexplained howru "How are you feeling?"
-        msg 40 hireply howru "How are you feeling?"
-        choice 1 howru good1 "I feel quite cozy, this space suit feels like a second skin."
-            msg 4 good1 good2 "Hah, it does, doesn't it?"
-            msg 4 good2 good3 "But take care, your suit seems to be leaking. I'd patch it up if I were you."
-            msg 4 good3 good4 "I'm all out of SuitPatch™ SuperGlue™ right now, otherwise i'd share."
-            msg 40 good4 canihelp "Can I help you with anything else, maybe?"
-        choice 1 howru headache1 "I got this apocalyptic headache..."
-            msg 4 headache1 headache2 "Heh, probably related to why you were passed out."
-            msg 4 headache2 headache3 "Go easy on yourself, I'm sure things will turn for the better."
-            msg 40 headache3 canihelp "Meanwhile, can I help you with anything?"
-        choice 1 howru disoriented "I... don't know, I'm pretty disoriented."
-            msg 40 disoriented canihelp "Oh no. Do you need a lowdown on reality?"
-            choice 1 canihelp where1 "Where are we?"
-                msg 4 where1 where2 "This is space, my friend."
-                msg 4 where2 where3 "That massive crescent over there, that's Juptiter."
-                msg 4 where3 where4 "We're about 150,000km away from it, on the very outside of it's rings."
-                msg 4 where4 where5 "This area is called the Thebe gossamer ring."
-                msg 4 where5 where6 "The moon Thebe is actually pretty close right now, flinging all those micros at us."
-                choice 4 where6 where6micros "Micros? What's that?"
-                    msg 4 where6micros canihelp "Micrometeorites. Those tiny 混蛋 that fly right through you, leaving holes in your suit. And your body."
-                msg 40 where6 canihelp "Anything else?"
-            choice 1 canihelp year1 "What year is this?"
-                msg 4 year1 year2 "Oh, is your Augmented Reality deactivated?"
-                msg 40 year2 canihelp "Push the TAB button, your space suit's AR will show you the date and time."
-            choice 1 canihelp why1 "Why am I here?"
-                msg 4 why1 why2 "That's a very philosophical question."
-                msg 4 why2 why3 "I don't know."
-                msg 40 why3 canihelp "It's probably related to the choices you made so far."
-            choice 1 canihelp whatnow1 "What should I do?"
-                msg 4 whatnow1 whatnow2 "Ah, that's the beauty of life."
-                msg 4 whatnow2 whatnow3 "You can just do whatever you want."
-                msg 6 whatnow3 whatnow4 "So long as you have the means, and respect people's boundaries."
-                msg 4 whatnow4 whatnow5 "I'm here mostly for the view and the peace."
-                msg 4 whatnow5 whatnow6 "Just look at Jupiter, it's mesmerizing, isn't it?"
-                msg 7 whatnow6 whatnow7 "So far away from everything, nobody expects anything from you."
-                msg 6 whatnow7 whatnow8 "If you want, you can take my sports racing capsule MeteorAceGT™ for a ride. It's right over there."
-                msg 8 whatnow8 whatnow9 "It rides like a punch in the face, don't hurt yourself, ok?"
-                choice 1 whatnow9 whatnow9tookind "You're too kind!"
-                    msg 4 whatnow9tookind whatnow10 "Ah, don't mention it!"
-                    msg 40 whatnow10 canihelp "There's also a half-decent pizza restaurant over there, look for the neon sign."
-                msg 40 whatnow9 canihelp "There's also a half-decent pizza restaurant over there, look for the neon sign."
-            choice 1 canihelp money1 "Do you have some money for me?"
-                msg 40 money1 money2 "Huh? What is money?"
-                choice 1 money2 money2currency "Currency? Flat round things that you can exchange for goods and services?"
-                    msg 4 money2currency money2currency2 "Uhm... are you talking about pizza?"
-                    msg 4 money2currency2 money2currency3 "I don't have any pizza with me right now."
-                    msg 4 money2currency3 canihelp "But there's a pizza place right over there, look for the neon sign."
-                msg 40 money2 canihelp "Well, anyway, need anything else?"
-            choice 1 canihelp chocolate "I think I'm good for now"
-            msg 4 canihelp chocolate "Well, anyway."
-        choice 1 howru alone "I just want to be alone right now"
-            msg 4 alone end_pizza "Oh, sure. Ping me if you need anything. I'll go back to playing my VR game."
-        msg 4 howru chocolate "Well, I hope you're ok."
-        msg 40 chocolate wantchocolate "I got some left-over instant hot chocolate, would you like some?"
-        choice 1 wantchocolate yeschocolate "Oh yes! Please!"
-            msg 4 yeschocolate chocolatehere "Here you go, my friend!"
-            msg 4 chocolatehere pizza "Received 1x ChuggaChug™ Instant Hot Chocolate"
-                lvl info
-        msg 4 wantchocolate pizza "I guess not. Well. I think I'll go back to playing my VR game. Ping me if you need anything."
-        msg 10 pizza end_pizza "Oh and make sure to check out the pizza place!"
-        choice 1 end_pizza end2 "Will do, bye!"
-            msg 0 end2 EXIT "Disconnected."
-                lvl info
-        msg 0 end_pizza EXIT "Disconnected."
-            lvl info
-        msg 0 end EXIT "Disconnected."
-            lvl info
 
 actor -300 0 40 suit
     relativeto player
-    id drifter
+    id Drifter
     name "Drifter"
-    chatid drifter
+    chatid Drifter
     oxygen 0.08
     scale 2
     collider capsule 1 0.5
-    chat drifter
-        name "Drifter"
-        msg 2 INIT dead "Error: No response"
-            lvl info
-        msg 15 dead outcold "No life signs detected"
-            lvl info
-        choice 0 outcold EXIT "Damn, it's gotta be moldy in that suit. How long has it been drifting?"
-        choice 0 outcold EXIT "Harvest some oxygen"
-            script refilloxygen 1 drifter
-        msg 0 outcold EXIT ""
 
 actor 100 -18000 2000 "orb_busstop"
     relativeto player
@@ -379,42 +238,7 @@ actor 100 -18000 2000 "orb_busstop"
         thrust 15 6 3 400 0.5
         rotationy -0.5
         scale 3
-        chatid "busstopclippy"
-        chat "busstopclippy"
-            name "StarTrans Clippy™"
-            msg 2 INIT question "Welcome at StarTrans Cargo Services!"
-            msg 2 question wait "Ready for a trip?  Available bus stops: Oscillation Station, Metis Prime Station"
-            msg 40 wait answer ""
-                sound none
-            choice 2 answer how1 "Bus stop?! How does this work?"
-                msg 6 how1 how2 "StarTrans Cargo Services is the most convenient way to travel the vast distances of space."
-                msg 6 how2 how3 "Just activate your suit's built-in cryostasis. A StarTrans carrier will pick you up and you will wake up at your destination in the blink of an eye."
-                msg 40 how3 answer "Of course we will supply you with free oxygen and ensure your safety."
-            choice 2 answer vehicle "Can I take a spacecraft with me?"
-                msg 40 vehicle answer "Absolutely."
-            choice 1 answer stopA1 "Take me to Oscillation Station, please."
-                msg 5 stopA1 stopA2 "StarTrans wishes you a pleasant journey."
-                    script cryofadeout
-                msg 0 stopA2 EXIT ""
-                    script cryotrip oscillation
-                    sound none
-            choice 1 answer stopB1 "Take me to Metis Prime Station, please."
-                msg 5 stopB1 stopB2 "StarTrans wishes you a pleasant journey."
-                    script cryofadeout
-                msg 0 stopB2 EXIT ""
-                    script cryotrip metisprime
-            choice 1 answer stopC1 "Take me to Serenity Station, please."
-                msg 5 stopC1 stopC2 "StarTrans wishes you a pleasant journey."
-                    script cryofadeout
-                msg 0 stopC2 EXIT ""
-                    script cryotrip serenity
-            choice 1 answer oxy "Can you please fill up my oxygen tank without taking me anywhere?"
-                msg 2 oxy EXIT "Acceptable."
-                    script refilloxygen 1000
-                    sound none
-            choice 2 answer bye "No, thank you."
-                msg 2 bye EXIT "Feel free to come back any time."
-            msg 0 answer EXIT "Connection terminated."
+        chatid ClippyTransSerenity
     actor 40 10 40 "orb_busstop"
         name "Light Orb"
         relativeto busstopclippy
@@ -439,13 +263,7 @@ actor 100 -18000 2000 "orb_busstop"
         thrust 1.2 1 1 400 1.5
         scale 2
         collider capsule 1 0.5
-        chatid "busstop1clippynpc1"
-        chat "busstop1clippynpc1"
-            name "Rudy"
-            msg 3 INIT cryo "Error: No response"
-                lvl info
-            msg 0 cryo EXIT "Lifeform in cryostasis detected."
-                lvl info
+        chatid NPCinCryoStasis
 
 actor 147002e3 165001e3 336e6 "orb_busstop"
     relativeto jupiter
@@ -465,8 +283,7 @@ actor 147002e3 165001e3 336e6 "orb_busstop"
         thrust 15 6 3 400 0.5
         rotationy -0.5
         scale 3
-        chatid "busstopclippy"
-        chat "busstopclippy"
+        chatid ClippyTransOscillation
     actor 40 10 40 "orb_busstop"
         name "Light Orb"
         relativeto busstopclippy2
@@ -502,8 +319,7 @@ actor 27643e3 -44e3 -124434e3 "orb_busstop"
         thrust 15 6 3 400 0.5
         rotationy -0.5
         scale 3
-        chatid "busstopclippy"
-        chat "busstopclippy"
+        chatid ClippyTransMetis
     actor 40 10 40 "orb_busstop"
         name "Light Orb"
         relativeto busstopclippy3
@@ -520,7 +336,3 @@ actor 27643e3 -44e3 -124434e3 "orb_busstop"
         name "Light Orb"
         relativeto busstopclippy3
         light "47FF00" 1000000
-
-chat error
-    name ERROR
-    msg 0 INIT EXIT "Unspecified conversation ID"
diff --git a/src/hud.rs b/src/hud.rs
index 70c2386..ff49c1c 100644
--- a/src/hud.rs
+++ b/src/hud.rs
@@ -11,7 +11,6 @@ pub const HUD_REFRESH_TIME: f32 = 0.1;
 pub const FONT: &str = "fonts/Yupiter-Regular.ttf";
 pub const LOG_MAX: usize = 20;
 pub const LOG_MAX_TIME_S: u64 = 20;
-pub const CHOICE_NONE: &str = "";
 pub const AMBIENT_LIGHT: f32 = 0.0; // Space is DARK
 pub const AMBIENT_LIGHT_AR: f32 = 15.0;
 //pub const REPLY_NUMBERS: [char; 10] = ['❶', '❷', '❸', '❹', '❺', '❻', '❼', '❽', '❾', '⓿'];
@@ -412,7 +411,7 @@ fn update_hud(
     q_camera: Query<(&Position, &LinearVelocity), With<actor::PlayerCamera>>,
     mut timer: ResMut<FPSUpdateTimer>,
     mut query: Query<&mut Text, With<GaugesText>>,
-    q_choices: Query<&chat::ChoiceAvailable>,
+    q_choices: Query<&chat::Choice>,
     mut query_chat: Query<&mut Text, (With<ChatText>, Without<GaugesText>)>,
     query_all_actors: Query<&actor::Actor>,
     settings: Res<settings::Settings>,
@@ -522,7 +521,7 @@ fn update_hud(
                 if count > 9 {
                     break;
                 }
-                let press_this = REPLY_NUMBERS[count];
+                let press_this = REPLY_NUMBERS[choice.key];
                 let reply = &choice.text;
                 //let recipient = &choice.recipient;
                 // TODO: indicate recipients if there's more than one
diff --git a/src/settings.rs b/src/settings.rs
index 9a98457..33341fd 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -1,6 +1,8 @@
 use bevy::prelude::*;
 use std::env;
 
+pub const DEFAULT_CHAT_SPEED: f32 = 10.0;
+
 #[derive(Resource)]
 pub struct Settings {
     pub dev_mode: bool,
@@ -16,6 +18,7 @@ pub struct Settings {
     pub zoom_sensitivity_factor: f32,
     pub font_size_hud: f32,
     pub font_size_conversations: f32,
+    pub chat_speed: f32,
     pub hud_active: bool,
     pub is_zooming: bool,
     pub third_person: bool,
@@ -100,6 +103,7 @@ impl Default for Settings {
             zoom_sensitivity_factor: 0.25,
             font_size_hud: 32.0,
             font_size_conversations: 32.0,
+            chat_speed: DEFAULT_CHAT_SPEED,
             hud_active: false,
             is_zooming: false,
             third_person: false,