diff --git a/capi/bind_gen/src/typescript.ts b/capi/bind_gen/src/typescript.ts
index d2c9f77a..c3e2cd29 100644
--- a/capi/bind_gen/src/typescript.ts
+++ b/capi/bind_gen/src/typescript.ts
@@ -658,11 +658,41 @@ export interface RunMetadataJson {
      */
     region_name: string,
     /**
-     * Stores all the variables. A variable is an arbitrary key value pair
-     * storing additional information about the category. An example of this
-     * may be whether Amiibos are used in this category.
+     * Stores all the speedrun.com variables. A variable is an arbitrary key
+     * value pair storing additional information about the category. An example
+     * of this may be whether Amiibos are used in this category.
      */
-    variables: { [key: string]: string },
+    speedrun_com_variables: { [key: string]: string | undefined },
+    /**
+     * Stores all the custom variables. A custom variable is a key value pair
+     * storing additional information about a run. Unlike the speedrun.com
+     * variables, these can be fully custom and don't need to correspond to
+     * anything on speedrun.com. Permanent custom variables can be specified by
+     * the runner. Additionally auto splitters or other sources may provide
+     * temporary custom variables that are not stored in the splits files.
+     */
+    custom_variables: { [key: string]: CustomVariableJson | undefined },
+}
+/**
+ * A custom variable is a key value pair storing additional information about a
+ * run. Unlike the speedrun.com variables, these can be fully custom and don't
+ * need to correspond to anything on speedrun.com. Permanent custom variables
+ * can be specified by the runner. Additionally auto splitters or other sources
+ * may provide temporary custom variables that are not stored in the splits
+ * files.
+ */
+export interface CustomVariableJson {
+    /**
+     * The current value of the custom variable. This may be provided by the
+     * runner in the run editor or it may be provided through other means such
+     * as an auto splitter.
+     */
+    value: string,
+    /**
+     * States whether the variable is permanent. Temporary variables don't get
+     * stored in splits files. They also don't get shown in the run editor.
+     */
+    is_permanent: boolean,
 }
 
 /**
diff --git a/capi/src/lib.rs b/capi/src/lib.rs
index 8d0e4d1d..ed069d38 100644
--- a/capi/src/lib.rs
+++ b/capi/src/lib.rs
@@ -37,8 +37,10 @@ pub mod previous_segment_component;
 pub mod run;
 pub mod run_editor;
 pub mod run_metadata;
-pub mod run_metadata_variable;
-pub mod run_metadata_variables_iter;
+pub mod run_metadata_custom_variable;
+pub mod run_metadata_custom_variables_iter;
+pub mod run_metadata_speedrun_com_variable;
+pub mod run_metadata_speedrun_com_variables_iter;
 pub mod segment;
 pub mod segment_history;
 pub mod segment_history_element;
@@ -64,7 +66,8 @@ pub mod title_component;
 pub mod title_component_state;
 pub mod total_playtime_component;
 
-use crate::run_metadata_variable::RunMetadataVariable;
+use crate::run_metadata_custom_variable::RunMetadataCustomVariable;
+use crate::run_metadata_speedrun_com_variable::RunMetadataSpeedrunComVariable;
 use crate::segment_history_element::SegmentHistoryElement;
 use livesplit_core::{Time, TimeSpan};
 
@@ -78,7 +81,8 @@ thread_local! {
     static TIME_SPAN: Cell<TimeSpan> = Cell::default();
     static TIME: Cell<Time> = Cell::default();
     static SEGMENT_HISTORY_ELEMENT: Cell<SegmentHistoryElement> = Cell::default();
-    static RUN_METADATA_VARIABLE: Cell<RunMetadataVariable> = Cell::new((ptr::null(), ptr::null()));
+    static RUN_METADATA_SPEEDRUN_COM_VARIABLE: Cell<RunMetadataSpeedrunComVariable> = Cell::new((ptr::null(), ptr::null()));
+    static RUN_METADATA_CUSTOM_VARIABLE: Cell<RunMetadataCustomVariable> = Cell::new((ptr::null(), ptr::null()));
 }
 
 fn output_time_span(time_span: TimeSpan) -> *const TimeSpan {
diff --git a/capi/src/run_editor.rs b/capi/src/run_editor.rs
index e70bb893..5f580316 100644
--- a/capi/src/run_editor.rs
+++ b/capi/src/run_editor.rs
@@ -158,24 +158,56 @@ pub extern "C" fn RunEditor_set_emulator_usage(this: &mut RunEditor, uses_emulat
     this.set_emulator_usage(uses_emulator);
 }
 
-/// Sets the variable with the name specified to the value specified. A
+/// Sets the speedrun.com variable with the name specified to the value specified. A
 /// variable is an arbitrary key value pair storing additional information
 /// about the category. An example of this may be whether Amiibos are used
 /// in this category. If the variable doesn't exist yet, it is being
 /// inserted.
 #[no_mangle]
-pub unsafe extern "C" fn RunEditor_set_variable(
+pub unsafe extern "C" fn RunEditor_set_speedrun_com_variable(
     this: &mut RunEditor,
     name: *const c_char,
     value: *const c_char,
 ) {
-    this.set_variable(str(name), str(value));
+    this.set_speedrun_com_variable(str(name), str(value));
 }
 
-/// Removes the variable with the name specified.
+/// Removes the speedrun.com variable with the name specified.
 #[no_mangle]
-pub unsafe extern "C" fn RunEditor_remove_variable(this: &mut RunEditor, name: *const c_char) {
-    this.remove_variable(str(name));
+pub unsafe extern "C" fn RunEditor_remove_speedrun_com_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+) {
+    this.remove_speedrun_com_variable(str(name));
+}
+
+/// Adds a new permanent custom variable. If there's a temporary variable with
+/// the same name, it gets turned into a permanent variable and its value stays.
+/// If a permanent variable with the name already exists, nothing happens.
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_add_custom_variable(this: &mut RunEditor, name: *const c_char) {
+    this.add_custom_variable(str(name));
+}
+
+/// Sets the value of a custom variable with the name specified. If the custom
+/// variable does not exist, or is not a permanent variable, nothing happens.
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_set_custom_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+    value: *const c_char,
+) {
+    this.set_custom_variable(str(name), str(value));
+}
+
+/// Removes the custom variable with the name specified. If the custom variable
+/// does not exist, or is not a permanent variable, nothing happens.
+#[no_mangle]
+pub unsafe extern "C" fn RunEditor_remove_custom_variable(
+    this: &mut RunEditor,
+    name: *const c_char,
+) {
+    this.remove_custom_variable(str(name));
 }
 
 /// Resets all the Metadata Information.
diff --git a/capi/src/run_metadata.rs b/capi/src/run_metadata.rs
index aae87b43..0d2f0548 100644
--- a/capi/src/run_metadata.rs
+++ b/capi/src/run_metadata.rs
@@ -2,7 +2,8 @@
 //! platform and region of the game. All of this information is optional.
 
 use super::output_str;
-use crate::run_metadata_variables_iter::OwnedRunMetadataVariablesIter;
+use crate::run_metadata_custom_variables_iter::OwnedRunMetadataCustomVariablesIter;
+use crate::run_metadata_speedrun_com_variables_iter::OwnedRunMetadataSpeedrunComVariablesIter;
 use livesplit_core::RunMetadata;
 use std::os::raw::c_char;
 
@@ -39,11 +40,20 @@ pub extern "C" fn RunMetadata_region_name(this: &RunMetadata) -> *const c_char {
     output_str(this.region_name())
 }
 
-/// Returns an iterator iterating over all the variables and their values
-/// that have been specified.
+/// Returns an iterator iterating over all the speedrun.com variables and their
+/// values that have been specified.
 #[no_mangle]
-pub extern "C" fn RunMetadata_variables(
+pub extern "C" fn RunMetadata_speedrun_com_variables(
     this: &'static RunMetadata,
-) -> OwnedRunMetadataVariablesIter {
-    Box::new(this.variables())
+) -> OwnedRunMetadataSpeedrunComVariablesIter {
+    Box::new(this.speedrun_com_variables())
+}
+
+/// Returns an iterator iterating over all the custom variables and their
+/// values. This includes both temporary and permanent variables.
+#[no_mangle]
+pub extern "C" fn RunMetadata_custom_variables(
+    this: &'static RunMetadata,
+) -> OwnedRunMetadataCustomVariablesIter {
+    Box::new(this.custom_variables())
 }
diff --git a/capi/src/run_metadata_custom_variable.rs b/capi/src/run_metadata_custom_variable.rs
new file mode 100644
index 00000000..3666ee0b
--- /dev/null
+++ b/capi/src/run_metadata_custom_variable.rs
@@ -0,0 +1,49 @@
+//! A custom variable is a key value pair storing additional information about a
+//! run. Unlike the speedrun.com variables, these can be fully custom and don't
+//! need to correspond to anything on speedrun.com. Permanent custom variables
+//! can be specified by the runner. Additionally auto splitters or other sources
+//! may provide temporary custom variables that are not stored in the splits
+//! files.
+
+use super::output_str;
+use livesplit_core::run::CustomVariable;
+use std::os::raw::c_char;
+
+/// type
+pub type RunMetadataCustomVariable = (*const String, *const CustomVariable);
+/// type
+pub type NullableRunMetadataCustomVariable = RunMetadataCustomVariable;
+/// type
+pub type OwnedRunMetadataCustomVariable = Box<RunMetadataCustomVariable>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariable_drop(this: OwnedRunMetadataCustomVariable) {
+    drop(this);
+}
+
+/// Accesses the name of this custom variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_name(
+    this: &RunMetadataCustomVariable,
+) -> *const c_char {
+    output_str(&*this.0)
+}
+
+/// Accesses the value of this custom variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_value(
+    this: &RunMetadataCustomVariable,
+) -> *const c_char {
+    output_str(&(*this.1).value)
+}
+
+/// Returns <TRUE> if the custom variable is permanent. Permanent variables get
+/// stored in the splits file and are visible in the run editor. Temporary
+/// variables are not.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataCustomVariable_is_permanent(
+    this: &RunMetadataCustomVariable,
+) -> bool {
+    (*this.1).is_permanent
+}
diff --git a/capi/src/run_metadata_custom_variables_iter.rs b/capi/src/run_metadata_custom_variables_iter.rs
new file mode 100644
index 00000000..cc8e82e4
--- /dev/null
+++ b/capi/src/run_metadata_custom_variables_iter.rs
@@ -0,0 +1,36 @@
+//! An iterator iterating over all the custom variables and their values
+//! that have been specified.
+
+use super::RUN_METADATA_CUSTOM_VARIABLE;
+use crate::run_metadata_custom_variable::{
+    NullableRunMetadataCustomVariable, RunMetadataCustomVariable,
+};
+use livesplit_core::{indexmap, run::CustomVariable};
+use std::ptr;
+
+/// type
+pub type RunMetadataCustomVariablesIter = indexmap::map::Iter<'static, String, CustomVariable>;
+/// type
+pub type OwnedRunMetadataCustomVariablesIter = Box<RunMetadataCustomVariablesIter>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariablesIter_drop(this: OwnedRunMetadataCustomVariablesIter) {
+    drop(this);
+}
+
+/// Accesses the next custom variable. Returns <NULL> if there are no more
+/// variables.
+#[no_mangle]
+pub extern "C" fn RunMetadataCustomVariablesIter_next(
+    this: &mut RunMetadataCustomVariablesIter,
+) -> *const NullableRunMetadataCustomVariable {
+    if let Some((name, value)) = this.next() {
+        RUN_METADATA_CUSTOM_VARIABLE.with(|output| {
+            output.set((name, value));
+            output.as_ptr() as *const RunMetadataCustomVariable
+        })
+    } else {
+        ptr::null()
+    }
+}
diff --git a/capi/src/run_metadata_speedrun_com_variable.rs b/capi/src/run_metadata_speedrun_com_variable.rs
new file mode 100644
index 00000000..07e5ee32
--- /dev/null
+++ b/capi/src/run_metadata_speedrun_com_variable.rs
@@ -0,0 +1,35 @@
+//! A speedrun.com variable is an arbitrary key value pair storing additional
+//! information about the category. An example of this may be whether Amiibos
+//! are used in the category.
+
+use super::output_str;
+use std::os::raw::c_char;
+
+/// type
+pub type RunMetadataSpeedrunComVariable = (*const String, *const String);
+/// type
+pub type NullableRunMetadataSpeedrunComVariable = RunMetadataSpeedrunComVariable;
+/// type
+pub type OwnedRunMetadataSpeedrunComVariable = Box<RunMetadataSpeedrunComVariable>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariable_drop(this: OwnedRunMetadataSpeedrunComVariable) {
+    drop(this);
+}
+
+/// Accesses the name of this speedrun.com variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_name(
+    this: &RunMetadataSpeedrunComVariable,
+) -> *const c_char {
+    output_str(&*this.0)
+}
+
+/// Accesses the value of this speedrun.com variable.
+#[no_mangle]
+pub unsafe extern "C" fn RunMetadataSpeedrunComVariable_value(
+    this: &RunMetadataSpeedrunComVariable,
+) -> *const c_char {
+    output_str(&*this.1)
+}
diff --git a/capi/src/run_metadata_speedrun_com_variables_iter.rs b/capi/src/run_metadata_speedrun_com_variables_iter.rs
new file mode 100644
index 00000000..12357f73
--- /dev/null
+++ b/capi/src/run_metadata_speedrun_com_variables_iter.rs
@@ -0,0 +1,38 @@
+//! An iterator iterating over all the speedrun.com variables and their values
+//! that have been specified.
+
+use super::RUN_METADATA_SPEEDRUN_COM_VARIABLE;
+use crate::run_metadata_speedrun_com_variable::{
+    NullableRunMetadataSpeedrunComVariable, RunMetadataSpeedrunComVariable,
+};
+use livesplit_core::indexmap;
+use std::ptr;
+
+/// type
+pub type RunMetadataSpeedrunComVariablesIter = indexmap::map::Iter<'static, String, String>;
+/// type
+pub type OwnedRunMetadataSpeedrunComVariablesIter = Box<RunMetadataSpeedrunComVariablesIter>;
+
+/// drop
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariablesIter_drop(
+    this: OwnedRunMetadataSpeedrunComVariablesIter,
+) {
+    drop(this);
+}
+
+/// Accesses the next speedrun.com variable. Returns <NULL> if there are no more
+/// variables.
+#[no_mangle]
+pub extern "C" fn RunMetadataSpeedrunComVariablesIter_next(
+    this: &mut RunMetadataSpeedrunComVariablesIter,
+) -> *const NullableRunMetadataSpeedrunComVariable {
+    if let Some((name, value)) = this.next() {
+        RUN_METADATA_SPEEDRUN_COM_VARIABLE.with(|output| {
+            output.set((name, value));
+            output.as_ptr() as *const RunMetadataSpeedrunComVariable
+        })
+    } else {
+        ptr::null()
+    }
+}
diff --git a/capi/src/run_metadata_variable.rs b/capi/src/run_metadata_variable.rs
deleted file mode 100644
index 81dd7a9e..00000000
--- a/capi/src/run_metadata_variable.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! A Run Metadata variable is an arbitrary key value pair storing additional
-//! information about the category. An example of this may be whether Amiibos
-//! are used in the category.
-
-use super::output_str;
-use std::os::raw::c_char;
-
-/// type
-pub type RunMetadataVariable = (*const String, *const String);
-/// type
-pub type NullableRunMetadataVariable = RunMetadataVariable;
-/// type
-pub type OwnedRunMetadataVariable = Box<RunMetadataVariable>;
-
-/// drop
-#[no_mangle]
-pub extern "C" fn RunMetadataVariable_drop(this: OwnedRunMetadataVariable) {
-    drop(this);
-}
-
-/// Accesses the name of this Run Metadata variable.
-#[no_mangle]
-pub unsafe extern "C" fn RunMetadataVariable_name(this: &RunMetadataVariable) -> *const c_char {
-    output_str(&*this.0)
-}
-
-/// Accesses the value of this Run Metadata variable.
-#[no_mangle]
-pub unsafe extern "C" fn RunMetadataVariable_value(this: &RunMetadataVariable) -> *const c_char {
-    output_str(&*this.1)
-}
diff --git a/capi/src/run_metadata_variables_iter.rs b/capi/src/run_metadata_variables_iter.rs
deleted file mode 100644
index 270d5214..00000000
--- a/capi/src/run_metadata_variables_iter.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! An iterator iterating over all the Run Metadata variables and their values
-//! that have been specified.
-
-use super::RUN_METADATA_VARIABLE;
-use crate::run_metadata_variable::{NullableRunMetadataVariable, RunMetadataVariable};
-use livesplit_core::indexmap;
-use std::ptr;
-
-/// type
-pub type RunMetadataVariablesIter = indexmap::map::Iter<'static, String, String>;
-/// type
-pub type OwnedRunMetadataVariablesIter = Box<RunMetadataVariablesIter>;
-
-/// drop
-#[no_mangle]
-pub extern "C" fn RunMetadataVariablesIter_drop(this: OwnedRunMetadataVariablesIter) {
-    drop(this);
-}
-
-/// Accesses the next Run Metadata variable. Returns <NULL> if there are no more
-/// variables.
-#[no_mangle]
-pub extern "C" fn RunMetadataVariablesIter_next(
-    this: &mut RunMetadataVariablesIter,
-) -> *const NullableRunMetadataVariable {
-    if let Some((name, value)) = this.next() {
-        RUN_METADATA_VARIABLE.with(|output| {
-            output.set((name, value));
-            output.as_ptr() as *const RunMetadataVariable
-        })
-    } else {
-        ptr::null()
-    }
-}
diff --git a/capi/src/text_component.rs b/capi/src/text_component.rs
index 0f53cb38..ee68067d 100644
--- a/capi/src/text_component.rs
+++ b/capi/src/text_component.rs
@@ -5,7 +5,7 @@
 use super::{output_vec, str, Json};
 use crate::component::OwnedComponent;
 use crate::text_component_state::OwnedTextComponentState;
-use livesplit_core::component::text::Component as TextComponent;
+use livesplit_core::{component::text::Component as TextComponent, Timer};
 use std::os::raw::c_char;
 
 /// type
@@ -32,9 +32,9 @@ pub extern "C" fn TextComponent_into_generic(this: OwnedTextComponent) -> OwnedC
 
 /// Encodes the component's state information as JSON.
 #[no_mangle]
-pub extern "C" fn TextComponent_state_as_json(this: &TextComponent) -> Json {
+pub extern "C" fn TextComponent_state_as_json(this: &TextComponent, timer: &Timer) -> Json {
     output_vec(|o| {
-        this.state().write_json(o).unwrap();
+        this.state(timer).write_json(o).unwrap();
     })
 }
 
@@ -61,6 +61,9 @@ pub unsafe extern "C" fn TextComponent_set_right(this: &mut TextComponent, text:
 
 /// Calculates the component's state.
 #[no_mangle]
-pub extern "C" fn TextComponent_state(this: &TextComponent) -> OwnedTextComponentState {
-    Box::new(this.state())
+pub extern "C" fn TextComponent_state(
+    this: &TextComponent,
+    timer: &Timer,
+) -> OwnedTextComponentState {
+    Box::new(this.state(timer))
 }
diff --git a/capi/src/text_component_state.rs b/capi/src/text_component_state.rs
index 04c3dd83..42f98565 100644
--- a/capi/src/text_component_state.rs
+++ b/capi/src/text_component_state.rs
@@ -1,8 +1,7 @@
 //! The state object describes the information to visualize for this component.
 
 use super::output_str;
-use livesplit_core::component::text::State as TextComponentState;
-use livesplit_core::component::text::Text;
+use livesplit_core::component::text::{State as TextComponentState, TextState};
 use std::os::raw::c_char;
 
 /// type
@@ -18,7 +17,7 @@ pub extern "C" fn TextComponentState_drop(this: OwnedTextComponentState) {
 /// string is returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_left(this: &TextComponentState) -> *const c_char {
-    if let Text::Split(left, _) = &this.text {
+    if let TextState::Split(left, _) = &this.text {
         output_str(left)
     } else {
         output_str("")
@@ -29,7 +28,7 @@ pub extern "C" fn TextComponentState_left(this: &TextComponentState) -> *const c
 /// string is returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_right(this: &TextComponentState) -> *const c_char {
-    if let Text::Split(_, right) = &this.text {
+    if let TextState::Split(_, right) = &this.text {
         output_str(right)
     } else {
         output_str("")
@@ -40,7 +39,7 @@ pub extern "C" fn TextComponentState_right(this: &TextComponentState) -> *const
 /// returned instead.
 #[no_mangle]
 pub extern "C" fn TextComponentState_center(this: &TextComponentState) -> *const c_char {
-    if let Text::Center(center) = &this.text {
+    if let TextState::Center(center) = &this.text {
         output_str(center)
     } else {
         output_str("")
@@ -50,7 +49,7 @@ pub extern "C" fn TextComponentState_center(this: &TextComponentState) -> *const
 /// Returns whether the text is split up into a left and right part.
 #[no_mangle]
 pub extern "C" fn TextComponentState_is_split(this: &TextComponentState) -> bool {
-    if let Text::Split(_, _) = this.text {
+    if let TextState::Split(_, _) = this.text {
         true
     } else {
         false
diff --git a/src/component/text.rs b/src/component/text/mod.rs
similarity index 63%
rename from src/component/text.rs
rename to src/component/text/mod.rs
index 626ed727..6c5f1b57 100644
--- a/src/component/text.rs
+++ b/src/component/text/mod.rs
@@ -5,11 +5,18 @@
 
 use super::key_value;
 use crate::platform::prelude::*;
-use crate::settings::{Color, Field, Gradient, SettingsDescription, Value};
+use crate::{
+    settings::{Color, Field, Gradient, SettingsDescription, Value},
+    timing::formatter,
+    Timer,
+};
 use alloc::borrow::Cow;
 use core::mem::replace;
 use serde::{Deserialize, Serialize};
 
+#[cfg(test)]
+mod tests;
+
 /// The Text Component simply visualizes any given text. This can either be a
 /// single centered text, or split up into a left and right text, which is
 /// suitable for a situation where you have a label and a value.
@@ -47,14 +54,29 @@ pub enum Text {
     /// A text that is split up into a left and right part. This is suitable for
     /// a situation where you have a label and a value.
     Split(String, String),
+    /// A custom variable with the name specified is supposed to be shown. The
+    /// boolean indicates whether the name should also be shown as a key value
+    /// pair.
+    Variable(String, bool),
+}
+
+/// The text that is supposed to be shown.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TextState {
+    /// A single centered text.
+    Center(String),
+    /// A text that is split up into a left and right part. This is suitable for
+    /// a situation where you have a label and a value.
+    Split(String, String),
 }
 
 impl Text {
     /// Returns whether the text is split up into a left and right part.
     pub fn is_split(&self) -> bool {
-        match self {
+        match *self {
             Text::Split(_, _) => true,
             Text::Center(_) => false,
+            Text::Variable(_, is_split) => is_split,
         }
     }
 
@@ -109,7 +131,7 @@ pub struct State {
     /// from the layout.
     pub right_color: Option<Color>,
     /// The text to show for the component.
-    pub text: Text,
+    pub text: TextState,
 }
 
 impl Default for Settings {
@@ -169,6 +191,7 @@ impl Component {
                 name.push_str(right);
                 name.into()
             }
+            Text::Variable(var_name, _) => var_name.as_str().into(),
         };
 
         if name.trim().is_empty() {
@@ -179,43 +202,84 @@ impl Component {
     }
 
     /// Calculates the component's state.
-    pub fn state(&self) -> State {
+    pub fn state(&self, timer: &Timer) -> State {
         State {
             background: self.settings.background,
             display_two_rows: self.settings.text.is_split() && self.settings.display_two_rows,
             left_center_color: self.settings.left_center_color,
             right_color: self.settings.right_color,
-            text: self.settings.text.clone(),
+            text: match &self.settings.text {
+                Text::Center(center) => TextState::Center(center.clone()),
+                Text::Split(left, right) => TextState::Split(left.clone(), right.clone()),
+                Text::Variable(var_name, is_split) => {
+                    let value = timer
+                        .run()
+                        .metadata()
+                        .custom_variable(&var_name)
+                        .map(|var| var.value.as_str())
+                        .filter(|value| !value.trim_start().is_empty())
+                        .unwrap_or(formatter::DASH);
+
+                    if *is_split {
+                        TextState::Split(var_name.clone(), value.to_owned())
+                    } else {
+                        TextState::Center(value.to_owned())
+                    }
+                }
+            },
         }
     }
 
     /// Accesses a generic description of the settings available for this
     /// component and their current values.
     pub fn settings_description(&self) -> SettingsDescription {
-        let (first, second, color_name) = match &self.settings.text {
-            Text::Center(text) => (
-                Field::new("Text".into(), text.to_string().into()),
-                None,
-                "Text Color",
-            ),
-            Text::Split(left, right) => (
-                Field::new("Left".into(), left.to_string().into()),
-                Some(Field::new("Right".into(), right.to_string().into())),
-                "Left Color",
-            ),
-        };
+        let (first, second, is_variable, is_split, left_color, right_color) =
+            match &self.settings.text {
+                Text::Center(text) => (
+                    Field::new("Text".into(), text.to_string().into()),
+                    None,
+                    false,
+                    false,
+                    "Text Color",
+                    "",
+                ),
+                Text::Split(left, right) => (
+                    Field::new("Left".into(), left.to_string().into()),
+                    Some(Field::new("Right".into(), right.to_string().into())),
+                    false,
+                    true,
+                    "Left Color",
+                    "Right Color",
+                ),
+                Text::Variable(var_name, is_split) => (
+                    Field::new("Variable".into(), var_name.to_string().into()),
+                    None,
+                    true,
+                    *is_split,
+                    if *is_split {
+                        "Name Color"
+                    } else {
+                        "Value Color"
+                    },
+                    "Value Color",
+                ),
+            };
 
         let mut fields = vec![
             Field::new("Background".into(), self.settings.background.into()),
-            Field::new("Split".into(), second.is_some().into()),
+            Field::new("Use Variable".into(), is_variable.into()),
+            Field::new("Split".into(), is_split.into()),
             first,
-            Field::new(color_name.into(), self.settings.left_center_color.into()),
+            Field::new(left_color.into(), self.settings.left_center_color.into()),
         ];
 
         if let Some(second) = second {
             fields.push(second);
+        }
+
+        if is_split {
             fields.push(Field::new(
-                "Right Color".into(),
+                right_color.into(),
                 self.settings.right_color.into(),
             ));
             fields.push(Field::new(
@@ -234,10 +298,33 @@ impl Component {
     /// This panics if the type of the value to be set is not compatible with
     /// the type of the setting's value. A panic can also occur if the index of
     /// the setting provided is out of bounds.
-    pub fn set_value(&mut self, index: usize, value: Value) {
+    pub fn set_value(&mut self, mut index: usize, value: Value) {
+        if index >= 5 {
+            if let Text::Variable(_, _) = &self.settings.text {
+                index += 1;
+            }
+        }
+
         match index {
             0 => self.settings.background = value.into(),
             1 => {
+                self.settings.text = match (value.into_bool().unwrap(), &mut self.settings.text) {
+                    (false, Text::Variable(name, true)) => {
+                        Text::Split(replace(name, String::new()), String::new())
+                    }
+                    (false, Text::Variable(name, false)) => {
+                        Text::Center(replace(name, String::new()))
+                    }
+                    (true, Text::Center(center)) => {
+                        Text::Variable(replace(center, String::new()), false)
+                    }
+                    (true, Text::Split(left, _)) => {
+                        Text::Variable(replace(left, String::new()), true)
+                    }
+                    _ => return,
+                };
+            }
+            2 => {
                 self.settings.text = match (value.into_bool().unwrap(), &mut self.settings.text) {
                     (true, Text::Center(center)) => {
                         self.settings.right_color = self.settings.left_center_color;
@@ -255,20 +342,28 @@ impl Component {
 
                         Text::Center(value)
                     }
+                    (should_be_split, Text::Variable(_, is_split)) => {
+                        *is_split = should_be_split;
+                        return;
+                    }
                     _ => return,
                 };
             }
-            2 => match &mut self.settings.text {
+            3 => match &mut self.settings.text {
                 Text::Center(center) => *center = value.into(),
                 Text::Split(left, _) => *left = value.into(),
+                Text::Variable(var_name, _) => *var_name = value.into(),
             },
-            3 => self.settings.left_center_color = value.into(),
-            4 => match &mut self.settings.text {
-                Text::Center(_) => panic!("Set right text when there's only a center text"),
+            4 => self.settings.left_center_color = value.into(),
+            5 => match &mut self.settings.text {
+                Text::Center(_) => panic!("Can't set right text when there's only a center text"),
                 Text::Split(_, right) => *right = value.into(),
+                Text::Variable(_, _) => {
+                    unreachable!("Shouldn't be able to set value for a variable")
+                }
             },
-            5 => self.settings.right_color = value.into(),
-            6 => self.settings.display_two_rows = value.into(),
+            6 => self.settings.right_color = value.into(),
+            7 => self.settings.display_two_rows = value.into(),
             _ => panic!("Unsupported Setting Index"),
         }
     }
diff --git a/src/component/text/tests.rs b/src/component/text/tests.rs
new file mode 100644
index 00000000..b654b1cc
--- /dev/null
+++ b/src/component/text/tests.rs
@@ -0,0 +1,75 @@
+use super::{Component, Text, TextState};
+use crate::{tests_helper::create_run, timing::formatter, Timer};
+
+#[test]
+fn resolves_variables() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::from("4:20:00");
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from("4:20:00"))
+    );
+
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), false);
+
+    let state = component.state(&timer);
+
+    assert_eq!(state.text, TextState::Center(String::from("4:20:00")));
+}
+
+#[test]
+fn uses_dash_for_non_existing_variables() {
+    let run = create_run(&["A"]);
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
+
+#[test]
+fn uses_dash_for_empty_string_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::new();
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
+
+#[test]
+fn uses_dash_for_whitespace_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut().custom_variable_mut("Goal Time").value = String::from("    ");
+    let timer = Timer::new(run).unwrap();
+
+    let mut component = Component::new();
+    component.settings_mut().text = Text::Variable(String::from("Goal Time"), true);
+
+    let state = component.state(&timer);
+
+    assert_eq!(
+        state.text,
+        TextState::Split(String::from("Goal Time"), String::from(formatter::DASH))
+    );
+}
diff --git a/src/layout/component.rs b/src/layout/component.rs
index 46bcdbf4..499fb932 100644
--- a/src/layout/component.rs
+++ b/src/layout/component.rs
@@ -83,7 +83,7 @@ impl Component {
                 ComponentState::Splits(component.state(timer, layout_settings))
             }
             Component::SumOfBest(component) => ComponentState::KeyValue(component.state(timer)),
-            Component::Text(component) => ComponentState::Text(component.state()),
+            Component::Text(component) => ComponentState::Text(component.state(timer)),
             Component::Timer(component) => {
                 ComponentState::Timer(component.state(timer, layout_settings))
             }
diff --git a/src/platform/no_std/indexmap.rs b/src/platform/no_std/indexmap.rs
index 37836340..3bc31c2e 100644
--- a/src/platform/no_std/indexmap.rs
+++ b/src/platform/no_std/indexmap.rs
@@ -29,6 +29,29 @@ pub mod map {
             }
         }
 
+        /// Return a reference to the value stored for key, if it is present, else None.
+        pub fn get<K2>(&self, key: &K2) -> Option<&V>
+        where
+            K: core::borrow::Borrow<K2>,
+            K2: ?Sized + PartialEq,
+        {
+            if let Some(index) = self.0.iter().position(|(k, _)| k.borrow() == key) {
+                Some(&self.0[index].1)
+            } else {
+                None
+            }
+        }
+
+        /// Get the given key’s corresponding entry in the map for insertion
+        /// and/or in-place manipulation.
+        pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+            Entry {
+                index: self.0.iter().position(|(k, _)| *k == key),
+                map: self,
+                key,
+            }
+        }
+
         /// Remove the key-value pair equivalent to key.
         pub fn shift_remove<K2>(&mut self, key: &K2)
         where
@@ -51,6 +74,29 @@ pub mod map {
         }
     }
 
+    pub struct Entry<'a, K, V> {
+        map: &'a mut IndexMap<K, V>,
+        index: Option<usize>,
+        key: K,
+    }
+
+    impl<'a, K, V> Entry<'a, K, V> {
+        /// Inserts a default-constructed value in the entry if it is vacant and
+        /// returns a mutable reference to it. Otherwise a mutable reference to
+        /// an already existent value is returned.
+        pub fn or_default(self) -> &'a mut V
+        where
+            V: Default,
+        {
+            if let Some(index) = self.index {
+                &mut self.map.0[index].1
+            } else {
+                self.map.0.push((self.key, Default::default()));
+                &mut self.map.0.last_mut().unwrap().1
+            }
+        }
+    }
+
     impl<'a, K, V> Iterator for Iter<'a, K, V> {
         type Item = (&'a K, &'a V);
         fn next(&mut self) -> Option<Self::Item> {
diff --git a/src/rendering/component/text.rs b/src/rendering/component/text.rs
index 7581b332..8cca984e 100644
--- a/src/rendering/component/text.rs
+++ b/src/rendering/component/text.rs
@@ -1,5 +1,5 @@
 use crate::{
-    component::text::{State, Text},
+    component::text::{State, TextState},
     layout::{LayoutDirection, LayoutState},
     rendering::{Backend, RenderContext, DEFAULT_TEXT_SIZE, PADDING, TEXT_ALIGN_TOP},
 };
@@ -12,7 +12,7 @@ pub(in crate::rendering) fn render(
 ) {
     context.render_rectangle([0.0, 0.0], [width, height], &component.background);
     match &component.text {
-        Text::Center(text) => context.render_text_centered(
+        TextState::Center(text) => context.render_text_centered(
             text,
             PADDING,
             width - PADDING,
@@ -22,7 +22,7 @@ pub(in crate::rendering) fn render(
                 .left_center_color
                 .unwrap_or(layout_state.text_color),
         ),
-        Text::Split(left, right) => context.render_key_value_component(
+        TextState::Split(left, right) => context.render_key_value_component(
             &left,
             &[],
             &right,
diff --git a/src/rendering/software/mod.rs b/src/rendering/software/mod.rs
index cbecc502..be5b94f9 100644
--- a/src/rendering/software/mod.rs
+++ b/src/rendering/software/mod.rs
@@ -4,14 +4,26 @@
 
 #[cfg(all(
     test,
-
-    // Without MMX the floating point calculations don't follow IEEE 754. So the
-    // tests fail to produce the correct checksums.
-    // FIXME: We use SSE as an approximation for the cfg, because MMX isn't
-    // supported by Rust just yet.
-    not(all(
-        target_arch = "x86",
-        not(target_feature = "sse"),
+    not(any(
+        // Without MMX the floating point calculations don't follow IEEE 754. So the
+        // tests fail to produce the correct checksums.
+        // FIXME: We use SSE as an approximation for the cfg, because MMX isn't
+        // supported by Rust just yet.
+        all(
+            target_arch = "x86",
+            not(target_feature = "sse"),
+        ),
+        // Additionally the x86_64-unknown-linux-musl target seems to be failing
+        // with lyon 0.15. I'd assume it's because of musl's libm doing
+        // something different than the glibc one, but I'm honestly not sure.
+        // FIXME: We likely want a perceptual image hash instead, which would be
+        // much more robust.
+        // https://github.com/LiveSplit/livesplit-core/issues/287
+        all(
+            target_os = "linux",
+            target_arch = "x86_64",
+            target_env = "musl",
+        ),
     )),
 ))]
 mod tests;
diff --git a/src/run/editor/mod.rs b/src/run/editor/mod.rs
index c84b31f4..e3c6a7ed 100644
--- a/src/run/editor/mod.rs
+++ b/src/run/editor/mod.rs
@@ -322,29 +322,82 @@ impl Editor {
         self.metadata_modified();
     }
 
-    /// Sets the variable with the name specified to the value specified. A
-    /// variable is an arbitrary key value pair storing additional information
-    /// about the category. An example of this may be whether Amiibos are used
-    /// in this category. If the variable doesn't exist yet, it is being
-    /// inserted.
-    pub fn set_variable<N, V>(&mut self, name: N, value: V)
+    /// Sets the speedrun.com variable with the name specified to the value
+    /// specified. A variable is an arbitrary key value pair storing additional
+    /// information about the category. An example of this may be whether
+    /// Amiibos are used in this category. If the variable doesn't exist yet, it
+    /// is being inserted.
+    pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
         V: Into<String>,
     {
-        self.run.metadata_mut().set_variable(name, value);
+        self.run
+            .metadata_mut()
+            .set_speedrun_com_variable(name, value);
         self.metadata_modified();
     }
 
-    /// Removes the variable with the name specified.
-    pub fn remove_variable<S>(&mut self, name: S)
+    /// Removes the speedrun.com variable with the name specified.
+    pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
     {
-        self.run.metadata_mut().remove_variable(name);
+        self.run.metadata_mut().remove_speedrun_com_variable(name);
         self.metadata_modified();
     }
 
+    /// Adds a new permanent custom variable. If there's a temporary variable
+    /// with the same name, it gets turned into a permanent variable and its
+    /// value stays. If a permanent variable with the name already exists,
+    /// nothing happens.
+    pub fn add_custom_variable<N>(&mut self, name: N)
+    where
+        N: Into<String>,
+    {
+        self.run
+            .metadata_mut()
+            .custom_variable_mut(name)
+            .permanent();
+        self.raise_run_edited();
+    }
+
+    /// Sets the value of a custom variable with the name specified. If the
+    /// custom variable does not exist, or is not a permanent variable, nothing
+    /// happens.
+    pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
+    where
+        N: Into<String>,
+        V: AsRef<str>,
+    {
+        let name = name.into();
+        if self.run.metadata().custom_variable(&name).is_none() {
+            return;
+        }
+        let variable = self.run.metadata_mut().custom_variable_mut(name);
+        if variable.is_permanent {
+            variable.value.clear();
+            variable.value.push_str(value.as_ref());
+            self.raise_run_edited();
+        }
+    }
+
+    /// Removes the custom variable with the name specified. If the custom
+    /// variable does not exist, or is not a permanent variable, nothing
+    /// happens.
+    pub fn remove_custom_variable<N>(&mut self, name: N)
+    where
+        N: AsRef<str>,
+    {
+        let name = name.as_ref();
+        if let Some(variable) = self.run.metadata().custom_variable(name) {
+            if variable.is_permanent {
+                self.run.metadata_mut().remove_custom_variable(name);
+                self.raise_run_edited();
+            }
+        }
+    }
+
     /// Resets all the Metadata Information.
     pub fn clear_metadata(&mut self) {
         self.run.metadata_mut().clear();
diff --git a/src/run/editor/tests/custom_variables.rs b/src/run/editor/tests/custom_variables.rs
new file mode 100644
index 00000000..440706f8
--- /dev/null
+++ b/src/run/editor/tests/custom_variables.rs
@@ -0,0 +1,45 @@
+use super::super::Editor;
+use crate::tests_helper::create_run;
+
+#[test]
+fn cant_edit_temporary_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .set_value("Bar");
+    let mut editor = Editor::new(run).unwrap();
+
+    editor.set_custom_variable("Foo", "No");
+
+    assert_eq!(
+        editor
+            .run()
+            .metadata()
+            .custom_variable("Foo")
+            .unwrap()
+            .value,
+        "Bar",
+    );
+}
+
+#[test]
+fn can_edit_permanent_variable() {
+    let mut run = create_run(&["A"]);
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
+    let mut editor = Editor::new(run).unwrap();
+
+    editor.set_custom_variable("Foo", "Ok");
+
+    assert_eq!(
+        editor
+            .run()
+            .metadata()
+            .custom_variable("Foo")
+            .unwrap()
+            .value,
+        "Ok",
+    );
+}
diff --git a/src/run/editor/tests/dissociate_run.rs b/src/run/editor/tests/dissociate_run.rs
index 90ee318b..81d3f84a 100644
--- a/src/run/editor/tests/dissociate_run.rs
+++ b/src/run/editor/tests/dissociate_run.rs
@@ -5,6 +5,10 @@ fn base() -> Editor {
     let mut run = Run::new();
     run.push_segment(Segment::new(""));
     run.push_segment(Segment::new(""));
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
 
     let mut editor = Editor::new(run).unwrap();
 
@@ -157,16 +161,16 @@ fn when_setting_emulator_usage() {
 }
 
 #[test]
-fn when_setting_variable() {
+fn when_setting_speedrun_com_variable() {
     let mut editor = base();
-    editor.set_variable("ok", "ok");
+    editor.set_speedrun_com_variable("ok", "ok");
     assert_eq!(editor.run().metadata().run_id, "");
 }
 
 #[test]
-fn when_removing_variable() {
+fn when_removing_speedrun_com_variable() {
     let mut editor = base();
-    editor.remove_variable("ok");
+    editor.remove_speedrun_com_variable("ok");
     assert_eq!(editor.run().metadata().run_id, "");
 }
 
@@ -183,3 +187,24 @@ fn not_when_generating_goal_comparison() {
     editor.generate_goal_comparison(TimeSpan::from_seconds(30.0));
     assert_ne!(editor.run().metadata().run_id, "");
 }
+
+#[test]
+fn not_when_creating_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Hello", "World");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
+
+#[test]
+fn not_when_setting_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Foo", "Bar2");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
+
+#[test]
+fn not_when_removing_custom_variable() {
+    let mut editor = base();
+    editor.remove_custom_variable("Foo");
+    assert_ne!(editor.run().metadata().run_id, "");
+}
diff --git a/src/run/editor/tests/mark_as_modified.rs b/src/run/editor/tests/mark_as_modified.rs
index 78172e41..9a1fbbd9 100644
--- a/src/run/editor/tests/mark_as_modified.rs
+++ b/src/run/editor/tests/mark_as_modified.rs
@@ -5,6 +5,10 @@ fn base() -> Editor {
     let mut run = Run::new();
     run.push_segment(Segment::new(""));
     run.push_segment(Segment::new(""));
+    run.metadata_mut()
+        .custom_variable_mut("Foo")
+        .permanent()
+        .set_value("Bar");
 
     let mut editor = Editor::new(run).unwrap();
 
@@ -23,7 +27,7 @@ fn base() -> Editor {
     editor.add_comparison("Other Comparison").unwrap();
     editor.active_segment().set_icon(&[2]);
     editor.set_game_icon(&[2]);
-    editor.set_variable("remove", "me");
+    editor.set_speedrun_com_variable("remove", "me");
 
     let mut run = editor.close();
     run.mark_as_unmodified();
@@ -190,16 +194,16 @@ fn when_setting_emulator_usage() {
 }
 
 #[test]
-fn when_setting_variable() {
+fn when_setting_speedrun_com_variable() {
     let mut editor = base();
-    editor.set_variable("some", "variable");
+    editor.set_speedrun_com_variable("some", "variable");
     assert!(editor.run().has_been_modified());
 }
 
 #[test]
-fn when_removing_variable() {
+fn when_removing_speedrun_com_variable() {
     let mut editor = base();
-    editor.remove_variable("remove");
+    editor.remove_speedrun_com_variable("remove");
     assert!(editor.run().has_been_modified());
 }
 
@@ -315,3 +319,24 @@ fn when_generating_goal_comparison() {
 }
 
 // FIXME: Cleaning Sum of Best
+
+#[test]
+fn when_creating_custom_variable() {
+    let mut editor = base();
+    editor.add_custom_variable("Hello");
+    assert!(editor.run().has_been_modified());
+}
+
+#[test]
+fn when_setting_custom_variable() {
+    let mut editor = base();
+    editor.set_custom_variable("Foo", "Bar2");
+    assert!(editor.run().has_been_modified());
+}
+
+#[test]
+fn when_removing_custom_variable() {
+    let mut editor = base();
+    editor.remove_custom_variable("Foo");
+    assert!(editor.run().has_been_modified());
+}
diff --git a/src/run/editor/tests/mod.rs b/src/run/editor/tests/mod.rs
index c1e2a1b2..8194f2a9 100644
--- a/src/run/editor/tests/mod.rs
+++ b/src/run/editor/tests/mod.rs
@@ -2,6 +2,7 @@ use super::Editor;
 use crate::{Run, Segment};
 
 mod comparison;
+mod custom_variables;
 mod dissociate_run;
 mod mark_as_modified;
 
diff --git a/src/run/mod.rs b/src/run/mod.rs
index bccb6a35..e53c4025 100644
--- a/src/run/mod.rs
+++ b/src/run/mod.rs
@@ -30,7 +30,7 @@ mod tests;
 
 pub use attempt::Attempt;
 pub use editor::{Editor, RenameError};
-pub use run_metadata::RunMetadata;
+pub use run_metadata::{CustomVariable, RunMetadata};
 pub use segment::Segment;
 pub use segment_history::SegmentHistory;
 
@@ -528,7 +528,7 @@ impl Run {
             };
 
             if show_variables {
-                for (name, value) in self.metadata.variables() {
+                for (name, value) in self.metadata.speedrun_com_variables() {
                     let name = name.trim_end_matches('?');
 
                     if unicase::eq(value.as_str(), "yes") {
diff --git a/src/run/parser/face_split.rs b/src/run/parser/face_split.rs
index 0d916c40..4bf27b34 100644
--- a/src/run/parser/face_split.rs
+++ b/src/run/parser/face_split.rs
@@ -18,6 +18,13 @@ pub enum Error {
         /// The underlying error.
         source: io::Error,
     },
+    /// Expected the goal, but didn't find it.
+    ExpectedGoal,
+    /// Failed to read the goal.
+    ReadGoal {
+        /// The underlying error.
+        source: io::Error,
+    },
     /// Expected the attempt count, but didn't find it.
     ExpectedAttemptCount,
     /// Failed to read the attempt count.
@@ -86,7 +93,15 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
     let mut lines = source.lines();
 
     run.set_category_name(lines.next().context(ExpectedTitle)?.context(ReadTitle)?);
-    lines.next(); // FIXME: Store Goal
+
+    let goal = lines.next().context(ExpectedGoal)?.context(ReadGoal)?;
+    if !goal.trim_start().is_empty() {
+        run.metadata_mut()
+            .custom_variable_mut("Goal")
+            .permanent()
+            .set_value(goal);
+    }
+
     run.set_attempt_count(
         lines
             .next()
diff --git a/src/run/parser/livesplit.rs b/src/run/parser/livesplit.rs
index 5b6fcf12..1df6de23 100644
--- a/src/run/parser/livesplit.rs
+++ b/src/run/parser/livesplit.rs
@@ -61,6 +61,8 @@ pub enum Error {
     },
     /// Failed to parse a boolean.
     ParseBool,
+    /// Failed to parse the scope of a custom variable.
+    Scope,
 }
 
 /// The Result type for the LiveSplit Parser.
@@ -218,7 +220,7 @@ fn parse_metadata<R: BufRead>(
                 text(reader, tag.into_buf(), |t| metadata.set_platform_name(t))
             } else if tag.name() == b"Region" {
                 text(reader, tag.into_buf(), |t| metadata.set_region_name(t))
-            } else if tag.name() == b"Variables" {
+            } else if tag.name() == b"Variables" || tag.name() == b"SpeedrunComVariables" {
                 parse_children(reader, tag.into_buf(), |reader, tag| {
                     let mut name = String::new();
                     let mut value = String::new();
@@ -228,7 +230,19 @@ fn parse_metadata<R: BufRead>(
                     type_hint(text(reader, tag.into_buf(), |t| {
                         value = t.into_owned();
                     }))?;
-                    metadata.set_variable(name, value);
+                    metadata.set_speedrun_com_variable(name, value);
+                    Ok(())
+                })
+            } else if tag.name() == b"CustomVariables" {
+                parse_children(reader, tag.into_buf(), |reader, tag| {
+                    let mut name = String::new();
+                    type_hint(attribute(&tag, b"name", |t| {
+                        name = t.into_owned();
+                    }))?;
+                    let var = metadata.custom_variable_mut(name).permanent();
+                    type_hint(text(reader, tag.into_buf(), |t| {
+                        var.set_value(t);
+                    }))?;
                     Ok(())
                 })
             } else {
diff --git a/src/run/parser/splits_io.rs b/src/run/parser/splits_io.rs
index 2c119a0c..da09fb3b 100644
--- a/src/run/parser/splits_io.rs
+++ b/src/run/parser/splits_io.rs
@@ -301,6 +301,42 @@ pub fn parse<R: Read>(source: R) -> Result<(Run, String)> {
         }
     }
 
+    if let Some(runner) = splits.runners.as_ref().and_then(|runners| runners.first()) {
+        let name = runner.longname.as_ref().unwrap_or(&runner.shortname);
+        if !name.trim_start().is_empty() {
+            run.metadata_mut()
+                .custom_variable_mut("Runner")
+                .permanent()
+                .set_value(name);
+        }
+        if let Some(links) = &runner.links {
+            if let Some(twitter_id) = &links.twitter_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Twitter")
+                    .permanent()
+                    .set_value(twitter_id);
+            }
+            if let Some(twitch_id) = &links.twitch_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Twitch")
+                    .permanent()
+                    .set_value(twitch_id);
+            }
+            if let Some(speedruncom_id) = &links.speedruncom_id {
+                run.metadata_mut()
+                    .custom_variable_mut("speedrun.com")
+                    .permanent()
+                    .set_value(speedruncom_id);
+            }
+            if let Some(splitsio_id) = &links.splitsio_id {
+                run.metadata_mut()
+                    .custom_variable_mut("Splits I/O")
+                    .permanent()
+                    .set_value(splitsio_id);
+            }
+        }
+    }
+
     for split in splits.segments.into_iter().flatten() {
         let mut segment = LiveSplitSegment::new(split.name.unwrap_or_default());
         segment.set_personal_best_split_time(split.ended_at.into());
diff --git a/src/run/parser/splitterz.rs b/src/run/parser/splitterz.rs
index 581631cb..c38d2ace 100644
--- a/src/run/parser/splitterz.rs
+++ b/src/run/parser/splitterz.rs
@@ -48,6 +48,11 @@ pub enum Error {
         /// The underlying error.
         source: io::Error,
     },
+    /// Failed to read a counter line.
+    CounterLine {
+        /// The underlying error.
+        source: io::Error,
+    },
 }
 
 /// The Result type for the SplitterZ parser.
@@ -74,7 +79,6 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
     let mut lines = source.lines();
     let line = lines.next().ok_or(Error::Empty)?.context(TitleLine)?;
     let mut splits = line.split(',');
-    // Title Stuff here, do later
     run.set_category_name(unescape(splits.next().ok_or(Error::ExpectedCategoryName)?));
     run.set_attempt_count(
         splits
@@ -84,7 +88,7 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
             .context(ParseAttemptCount)?,
     );
 
-    for line in lines {
+    for line in &mut lines {
         let line = line.context(Line)?;
         if !line.is_empty() {
             let mut splits = line.split(',');
@@ -128,6 +132,18 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
         }
     }
 
+    for line in lines {
+        if let Some(counter) = line.context(CounterLine)?.split(',').next() {
+            run.metadata_mut()
+                .custom_variable_mut(unescape(counter))
+                .permanent()
+                .set_value("0");
+        }
+        // The other two lines are not that useful. The number is how much to
+        // increment the counter each time and the other is a boolean that does
+        // not seem to be exposed to the UI.
+    }
+
     Ok(run)
 }
 
@@ -143,10 +159,12 @@ SegmentName,0:00:00.00,0.00
 SegmentName,0:00:00.00,0.00
 
 Counter,1,True
-Counter,1,True
+Counter2,1,True
 "#;
 
         let run = parse(RUN, false).unwrap();
         assert_eq!(run.len(), 3);
+        assert_eq!(run.metadata.custom_variable_value("Counter"), Some("0"));
+        assert_eq!(run.metadata.custom_variable_value("Counter2"), Some("0"));
     }
 }
diff --git a/src/run/parser/worstrun.rs b/src/run/parser/worstrun.rs
index 26b13b56..70303c45 100644
--- a/src/run/parser/worstrun.rs
+++ b/src/run/parser/worstrun.rs
@@ -19,7 +19,7 @@ pub enum Error {
     },
 }
 
-/// The Result type for the Urn Parser.
+/// The Result type for the worstrun Parser.
 pub type Result<T> = StdResult<T, Error>;
 
 #[derive(Deserialize)]
diff --git a/src/run/parser/wsplit.rs b/src/run/parser/wsplit.rs
index efef860e..ed7a4d2c 100644
--- a/src/run/parser/wsplit.rs
+++ b/src/run/parser/wsplit.rs
@@ -136,8 +136,10 @@ pub fn parse<R: BufRead>(source: R, load_icons: bool) -> Result<Run> {
         if run.category_name().is_empty() {
             run.set_category_name(goal);
         } else {
-            let category_name = format!("{} (Goal: {})", run.category_name(), goal);
-            run.set_category_name(category_name);
+            run.metadata_mut()
+                .custom_variable_mut("Goal")
+                .permanent()
+                .set_value(goal);
         }
     }
 
@@ -169,7 +171,8 @@ Jimmy,0,219.68,134.2
 "#;
 
         let run = parse(RUN, false).unwrap();
-        assert_eq!(run.category_name(), "WarioWare, Inc (Goal: sub 2h)");
+        assert_eq!(run.category_name(), "WarioWare, Inc");
+        assert_eq!(run.metadata().custom_variable_value("Goal"), Some("sub 2h"));
         assert_eq!(run.len(), 2);
     }
 
diff --git a/src/run/run_metadata.rs b/src/run/run_metadata.rs
index 2e3e26f5..98444500 100644
--- a/src/run/run_metadata.rs
+++ b/src/run/run_metadata.rs
@@ -2,6 +2,47 @@ use crate::indexmap::map::{IndexMap, Iter};
 use crate::platform::prelude::*;
 use serde::{Deserialize, Serialize};
 
+/// A custom variable is a key value pair storing additional information about a
+/// run. Unlike the speedrun.com variables, these can be fully custom and don't
+/// need to correspond to anything on speedrun.com. Permanent custom variables
+/// can be specified by the runner. Additionally auto splitters or other sources
+/// may provide temporary custom variables that are not stored in the splits
+/// files.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CustomVariable {
+    /// The current value of the custom variable. This may be provided by the
+    /// runner in the run editor or it may be provided through other means such
+    /// as an auto splitter.
+    pub value: String,
+    /// States whether the variable is permanent. Temporary variables don't get
+    /// stored in splits files. They also don't get shown in the run editor.
+    pub is_permanent: bool,
+}
+
+impl CustomVariable {
+    /// Turns the custom variable into a permanent one. If it already is
+    /// permanent variable, nothing happens.
+    pub fn permanent(&mut self) -> &mut Self {
+        self.is_permanent = true;
+        self
+    }
+
+    /// Sets the value of the custom variable.
+    pub fn set_value<S>(&mut self, value: S)
+    where
+        S: AsRef<str>,
+    {
+        self.value.clear();
+        self.value.push_str(value.as_ref());
+    }
+
+    /// Clears the value of the custom variable. This does not delete the custom
+    /// variable.
+    pub fn clear_value(&mut self) {
+        self.value.clear();
+    }
+}
+
 /// The Run Metadata stores additional information about a run, like the
 /// platform and region of the game. All of this information is optional.
 #[derive(Default, Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -19,10 +60,19 @@ pub struct RunMetadata {
     /// The name of the region this game is from. This may be empty if it's not
     /// specified.
     pub region_name: String,
-    /// Stores all the variables. A variable is an arbitrary key value pair
-    /// storing additional information about the category. An example of this
-    /// may be whether Amiibos are used in this category.
-    pub variables: IndexMap<String, String>,
+    /// Stores all the speedrun.com variables. A speedrun.com variable is a key
+    /// value pair storing additional information about the category. An example
+    /// of this may be whether Amiibos are used in this category. Use a custom
+    /// variable for storing arbitrary key value pairs that are independent of
+    /// speedrun.com.
+    pub speedrun_com_variables: IndexMap<String, String>,
+    /// Stores all the custom variables. A custom variable is a key value pair
+    /// storing additional information about a run. Unlike the speedrun.com
+    /// variables, these can be fully custom and don't need to correspond to
+    /// anything on speedrun.com. Permanent custom variables can be specified by
+    /// the runner. Additionally auto splitters or other sources may provide
+    /// temporary custom variables that are not stored in the splits files.
+    pub custom_variables: IndexMap<String, CustomVariable>,
 }
 
 impl RunMetadata {
@@ -103,31 +153,73 @@ impl RunMetadata {
         self.region_name.push_str(region_name.as_ref());
     }
 
-    /// Sets the variable with the name specified to the value specified. A
-    /// variable is an arbitrary key value pair storing additional information
-    /// about the category. An example of this may be whether Amiibos are used
-    /// in this category. If the variable doesn't exist yet, it is being
-    /// inserted.
-    pub fn set_variable<N, V>(&mut self, name: N, value: V)
+    /// Sets the speedrun.com variable with the name specified to the value
+    /// specified. A speedrun.com variable is an arbitrary key value pair
+    /// storing additional information about the category. An example of this
+    /// may be whether Amiibos are used in this category. If the variable
+    /// doesn't exist yet, it is being inserted.
+    pub fn set_speedrun_com_variable<N, V>(&mut self, name: N, value: V)
     where
         N: Into<String>,
         V: Into<String>,
     {
-        self.variables.insert(name.into(), value.into());
+        self.speedrun_com_variables
+            .insert(name.into(), value.into());
+    }
+
+    /// Removes the speedrun.com variable with the name specified.
+    pub fn remove_speedrun_com_variable<S>(&mut self, name: S)
+    where
+        S: AsRef<str>,
+    {
+        self.speedrun_com_variables.shift_remove(name.as_ref());
+    }
+
+    /// Returns an iterator iterating over all the speedrun.com variables and
+    /// their values that have been specified.
+    pub fn speedrun_com_variables(&self) -> Iter<'_, String, String> {
+        self.speedrun_com_variables.iter()
+    }
+
+    /// Accesses the custom variable with the name specified if there is one.
+    pub fn custom_variable<S>(&self, name: S) -> Option<&CustomVariable>
+    where
+        S: AsRef<str>,
+    {
+        self.custom_variables.get(name.as_ref())
+    }
+
+    /// Accesses the value of the custom variable with the name specified if
+    /// there is one.
+    pub fn custom_variable_value<S>(&self, name: S) -> Option<&str>
+    where
+        S: AsRef<str>,
+    {
+        Some(&self.custom_variable(name)?.value)
+    }
+
+    /// Mutably accesses the custom variable with the name specified. If the
+    /// variable does not exist, it gets created as a temporary variable.
+    pub fn custom_variable_mut<S>(&mut self, name: S) -> &mut CustomVariable
+    where
+        S: Into<String>,
+    {
+        self.custom_variables.entry(name.into()).or_default()
     }
 
-    /// Removes the variable with the name specified.
-    pub fn remove_variable<S>(&mut self, name: S)
+    /// Removes the custom variable with the name specified. Nothing happens if
+    /// the variable does not exist.
+    pub fn remove_custom_variable<S>(&mut self, name: S)
     where
         S: AsRef<str>,
     {
-        self.variables.shift_remove(name.as_ref());
+        self.custom_variables.shift_remove(name.as_ref());
     }
 
-    /// Returns an iterator iterating over all the variables and their values
-    /// that have been specified.
-    pub fn variables(&self) -> Iter<'_, String, String> {
-        self.variables.iter()
+    /// Returns an iterator iterating over all the custom variables and their
+    /// values. This includes both temporary and permanent variables.
+    pub fn custom_variables(&self) -> Iter<'_, String, CustomVariable> {
+        self.custom_variables.iter()
     }
 
     /// Resets all the Metadata Information.
@@ -136,6 +228,7 @@ impl RunMetadata {
         self.platform_name.clear();
         self.region_name.clear();
         self.uses_emulator = false;
-        self.variables.clear();
+        self.speedrun_com_variables.clear();
+        self.custom_variables.clear();
     }
 }
diff --git a/src/run/saver/livesplit.rs b/src/run/saver/livesplit.rs
index afe6f8d1..86226659 100644
--- a/src/run/saver/livesplit.rs
+++ b/src/run/saver/livesplit.rs
@@ -250,7 +250,7 @@ pub fn save_run<W: Write>(run: &Run, writer: W) -> Result<()> {
 
     writer.write_event(Event::Decl(BytesDecl::new(b"1.0", Some(b"UTF-8"), None)))?;
     writer.write_event(Event::Start(BytesStart::borrowed(
-        br#"Run version="1.7.1""#,
+        br#"Run version="1.8.0""#,
         3,
     )))?;
 
@@ -279,14 +279,28 @@ pub fn save_run<W: Write>(run: &Run, writer: W) -> Result<()> {
 
     scoped_iter(
         writer,
-        new_tag(b"Variables"),
-        metadata.variables(),
+        new_tag(b"SpeedrunComVariables"),
+        metadata.speedrun_com_variables(),
         |writer, (name, value)| {
             let mut tag = new_tag(b"Variable");
             tag.push_attribute((&b"name"[..], name.as_bytes()));
             text(writer, tag, value)
         },
     )?;
+
+    scoped_iter(
+        writer,
+        new_tag(b"CustomVariables"),
+        metadata
+            .custom_variables()
+            .filter(|(_, var)| var.is_permanent),
+        |writer, (name, var)| {
+            let mut tag = new_tag(b"Variable");
+            tag.push_attribute((&b"name"[..], name.as_bytes()));
+            text(writer, tag, &var.value)
+        },
+    )?;
+
     write_end(writer, b"Metadata")?;
 
     time_span(writer, new_tag(b"Offset"), run.offset(), buf)?;
diff --git a/src/run/tests/metadata.rs b/src/run/tests/metadata.rs
index 380057c2..44f78a4d 100644
--- a/src/run/tests/metadata.rs
+++ b/src/run/tests/metadata.rs
@@ -1,19 +1,23 @@
 use super::super::RunMetadata;
 
 #[test]
-fn removing_shifts_the_variables() {
+fn removing_shifts_the_speedrun_com_variables() {
     let mut data = RunMetadata::new();
-    data.set_variable("A", "A");
-    data.set_variable("B", "B");
-    data.set_variable("C", "C");
-    data.set_variable("D", "D");
+    data.set_speedrun_com_variable("A", "A");
+    data.set_speedrun_com_variable("B", "B");
+    data.set_speedrun_com_variable("C", "C");
+    data.set_speedrun_com_variable("D", "D");
     assert_eq!(
-        data.variables().map(|(k, _)| k).collect::<Vec<_>>(),
+        data.speedrun_com_variables()
+            .map(|(k, _)| k)
+            .collect::<Vec<_>>(),
         ["A", "B", "C", "D"]
     );
-    data.remove_variable("B");
+    data.remove_speedrun_com_variable("B");
     assert_eq!(
-        data.variables().map(|(k, _)| k).collect::<Vec<_>>(),
+        data.speedrun_com_variables()
+            .map(|(k, _)| k)
+            .collect::<Vec<_>>(),
         ["A", "C", "D"]
     );
 }
diff --git a/src/timing/timer/mod.rs b/src/timing/timer/mod.rs
index 82cc7c78..3472241f 100644
--- a/src/timing/timer/mod.rs
+++ b/src/timing/timer/mod.rs
@@ -599,6 +599,21 @@ impl Timer {
         }
     }
 
+    /// Sets the value of a custom variable with the name specified. If the
+    /// variable does not exist, a temporary variable gets created that will not
+    /// be stored in the splits file.
+    pub fn set_custom_variable<N, V>(&mut self, name: N, value: V)
+    where
+        N: Into<String>,
+        V: AsRef<str>,
+    {
+        let var = self.run.metadata_mut().custom_variable_mut(name);
+        var.set_value(value);
+        if var.is_permanent {
+            self.run.mark_as_modified();
+        }
+    }
+
     fn update_attempt_history(&mut self) {
         let time = if self.phase == Ended {
             self.current_time()
diff --git a/src/timing/timer/tests/mark_as_modified.rs b/src/timing/timer/tests/mark_as_modified.rs
index 6c023589..a2a146c7 100644
--- a/src/timing/timer/tests/mark_as_modified.rs
+++ b/src/timing/timer/tests/mark_as_modified.rs
@@ -1,8 +1,12 @@
 use crate::{Run, Segment, TimeSpan, Timer, TimingMethod};
 
 fn timer() -> Timer {
-    use super::timer;
-    let timer = timer();
+    use super::run;
+    let mut run = run();
+    run.metadata_mut()
+        .custom_variable_mut("Permanent")
+        .permanent();
+    let timer = Timer::new(run).unwrap();
     assert!(!timer.run().has_been_modified());
     timer
 }
@@ -163,3 +167,19 @@ fn not_when_pausing_resuming_or_setting_game_time_without_an_attempt() {
     timer.set_loading_times(TimeSpan::default());
     assert!(!timer.run().has_been_modified());
 }
+
+#[test]
+fn when_setting_permanent_custom_variables() {
+    let mut timer = timer();
+    timer.set_custom_variable("Permanent", "okok");
+    assert!(timer.run().has_been_modified());
+}
+
+#[test]
+fn not_when_setting_temporary_custom_variables() {
+    let mut timer = timer();
+    timer.set_custom_variable("Foo", "Bar");
+    assert!(!timer.run().has_been_modified());
+    timer.set_custom_variable("Foo", "Bar2");
+    assert!(!timer.run().has_been_modified());
+}
diff --git a/src/timing/timer/tests/mod.rs b/src/timing/timer/tests/mod.rs
index d8677e27..5b35777a 100644
--- a/src/timing/timer/tests/mod.rs
+++ b/src/timing/timer/tests/mod.rs
@@ -3,6 +3,7 @@ use crate::tests_helper::{run_with_splits, run_with_splits_opt, start_run};
 use crate::{Run, Segment, TimeSpan, Timer, TimerPhase, TimingMethod};
 
 mod mark_as_modified;
+mod variables;
 
 fn run() -> Run {
     let mut run = Run::new();
diff --git a/src/timing/timer/tests/variables.rs b/src/timing/timer/tests/variables.rs
new file mode 100644
index 00000000..1d319cf2
--- /dev/null
+++ b/src/timing/timer/tests/variables.rs
@@ -0,0 +1,115 @@
+use crate::tests_helper::create_timer;
+
+#[test]
+fn can_set_variable() {
+    let mut timer = create_timer(&["A"]);
+
+    assert!(timer.run().metadata().custom_variable("Points").is_none());
+
+    timer.set_custom_variable("Points", "10");
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "10"
+    );
+
+    timer.start();
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "10"
+    );
+
+    timer.set_custom_variable("Points", "20");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "20"
+    );
+
+    timer.set_custom_variable("Points", "30");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "30"
+    );
+
+    timer.split();
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "30"
+    );
+
+    timer.set_custom_variable("Points", "40");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "40"
+    );
+
+    timer.set_custom_variable("Points", "50");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "50"
+    );
+
+    timer.reset(true);
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "50"
+    );
+
+    timer.set_custom_variable("Points", "60");
+
+    assert_eq!(
+        timer
+            .run()
+            .metadata()
+            .custom_variable_value("Points")
+            .unwrap(),
+        "60"
+    );
+
+    assert!(
+        !timer
+            .run()
+            .metadata()
+            .custom_variable("Points")
+            .unwrap()
+            .is_permanent,
+    );
+}