diff --git a/crates/state/src/cursor.rs b/crates/state/src/cursor.rs
index f629507a0..eec527220 100644
--- a/crates/state/src/cursor.rs
+++ b/crates/state/src/cursor.rs
@@ -1,6 +1,9 @@
-use std::sync::{
-    Arc,
-    Mutex,
+use std::{
+    num::ParseIntError,
+    sync::{
+        Arc,
+        Mutex,
+    },
 };
 
 use freya_common::{
@@ -72,7 +75,11 @@ impl ParseAttribute for CursorState {
             AttributeName::CursorIndex => {
                 if let Some(value) = attr.value.as_text() {
                     if value != "none" {
-                        self.position = Some(value.parse().map_err(|_| ParseError)?);
+                        self.position = Some(
+                            value
+                                .parse()
+                                .map_err(|err: ParseIntError| ParseError(err.to_string()))?,
+                        );
                     }
                 }
             }
@@ -88,7 +95,11 @@ impl ParseAttribute for CursorState {
             }
             AttributeName::CursorId => {
                 if let Some(value) = attr.value.as_text() {
-                    self.cursor_id = Some(value.parse().map_err(|_| ParseError)?);
+                    self.cursor_id = Some(
+                        value
+                            .parse()
+                            .map_err(|err: ParseIntError| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::Highlights => {
diff --git a/crates/state/src/font_style.rs b/crates/state/src/font_style.rs
index 18c033488..3807cff76 100644
--- a/crates/state/src/font_style.rs
+++ b/crates/state/src/font_style.rs
@@ -1,6 +1,12 @@
-use std::sync::{
-    Arc,
-    Mutex,
+use std::{
+    num::{
+        ParseFloatError,
+        ParseIntError,
+    },
+    sync::{
+        Arc,
+        Mutex,
+    },
 };
 
 use freya_common::CompositorDirtyNodes;
@@ -23,11 +29,13 @@ use torin::torin::Torin;
 
 use crate::{
     CustomAttributeValues,
-    ExtSplit,
     Parse,
     ParseAttribute,
+    ParseError,
     TextHeight,
+    TextHeightBehavior,
     TextOverflow,
+    Token,
 };
 
 #[derive(Debug, Clone, PartialEq, Component)]
@@ -123,7 +131,7 @@ impl ParseAttribute for FontStyleState {
     fn parse_attribute(
         &mut self,
         attr: freya_native_core::prelude::OwnedAttributeView<CustomAttributeValues>,
-    ) -> Result<(), crate::ParseError> {
+    ) -> Result<(), ParseError> {
         match attr.attribute {
             AttributeName::Color => {
                 if let Some(value) = attr.value.as_text() {
@@ -136,15 +144,13 @@ impl ParseAttribute for FontStyleState {
             }
             AttributeName::TextShadow => {
                 if let Some(value) = attr.value.as_text() {
-                    self.text_shadows = value
-                        .split_excluding_group(',', '(', ')')
-                        .map(|chunk| TextShadow::parse(chunk).unwrap_or_default())
-                        .collect();
+                    self.text_shadows = TextShadow::parse_with_separator(value, &Token::Comma)?;
                 }
             }
             AttributeName::FontFamily => {
                 if let Some(value) = attr.value.as_text() {
                     let families = value.split(',');
+
                     self.font_family = families
                         .into_iter()
                         .map(|f| f.trim().to_string())
@@ -167,84 +173,67 @@ impl ParseAttribute for FontStyleState {
             }
             AttributeName::TextAlign => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(text_align) = TextAlign::parse(value) {
-                        self.text_align = text_align;
-                    }
+                    self.text_align = TextAlign::parse(value)?;
                 }
             }
             AttributeName::MaxLines => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(max_lines) = value.parse() {
-                        self.max_lines = Some(max_lines);
-                    }
+                    self.max_lines = Some(
+                        value
+                            .parse()
+                            .map_err(|err: ParseIntError| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::TextOverflow => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(text_overflow) = TextOverflow::parse(value) {
-                        self.text_overflow = text_overflow;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.text_overflow = TextOverflow::parse(value)?;
                 }
             }
             AttributeName::FontStyle => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_slant) = Slant::parse(value) {
-                        self.font_slant = font_slant;
-                    }
+                    self.font_slant = Slant::parse(value)?;
                 }
             }
             AttributeName::FontWeight => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_weight) = Weight::parse(value) {
-                        self.font_weight = font_weight;
-                    }
+                    self.font_weight = Weight::parse(value)?;
                 }
             }
             AttributeName::FontWidth => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_width) = Width::parse(value) {
-                        self.font_width = font_width;
-                    }
+                    self.font_width = Width::parse(value)?;
                 }
             }
             AttributeName::Decoration => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(decoration) = TextDecoration::parse(value) {
-                        self.decoration.ty = decoration;
-                    }
+                    self.decoration.ty = TextDecoration::parse(value)?;
                 }
             }
             AttributeName::DecorationStyle => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(style) = TextDecorationStyle::parse(value) {
-                        self.decoration.style = style;
-                    }
+                    self.decoration.style = TextDecorationStyle::parse(value)?;
                 }
             }
             AttributeName::DecorationColor => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(new_decoration_color) = Color::parse(value) {
-                        self.decoration.color = new_decoration_color;
-                    }
+                    self.decoration.color = Color::parse(value)?;
                 } else {
                     self.decoration.color = self.color;
                 }
             }
             AttributeName::WordSpacing => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(word_spacing) = value.parse() {
-                        self.word_spacing = word_spacing;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.word_spacing = value
+                        .parse()
+                        .map_err(|err: ParseFloatError| ParseError(err.to_string()))?;
                 }
             }
             AttributeName::LetterSpacing => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(letter_spacing) = value.parse() {
-                        self.letter_spacing = letter_spacing;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.letter_spacing = value
+                        .parse()
+                        .map_err(|err: ParseFloatError| ParseError(err.to_string()))?;
                 }
             }
             AttributeName::TextHeight => {
diff --git a/crates/state/src/layer.rs b/crates/state/src/layer.rs
index 24bed3c99..4f52ab58d 100644
--- a/crates/state/src/layer.rs
+++ b/crates/state/src/layer.rs
@@ -40,7 +40,9 @@ impl ParseAttribute for LayerState {
         match attr.attribute {
             AttributeName::Layer => {
                 if let Some(value) = attr.value.as_text() {
-                    let layer = value.parse::<i16>().map_err(|_| ParseError)?;
+                    let layer = value
+                        .parse::<i16>()
+                        .map_err(|err| ParseError(err.to_string()))?;
                     self.layer -= layer;
                     self.layer_for_children += layer;
                 }
diff --git a/crates/state/src/layout.rs b/crates/state/src/layout.rs
index 753123534..34307c624 100644
--- a/crates/state/src/layout.rs
+++ b/crates/state/src/layout.rs
@@ -102,18 +102,32 @@ impl ParseAttribute for LayoutState {
                 if let Some(value) = attr.value.as_text() {
                     self.direction = match value {
                         "horizontal" => DirectionMode::Horizontal,
-                        _ => DirectionMode::Vertical,
+                        "vertical" => DirectionMode::Vertical,
+                        value => {
+                            return Err(ParseError::invalid_ident(
+                                value,
+                                &["horizontal", "vertical"],
+                            ))
+                        }
                     }
                 }
             }
             AttributeName::OffsetY => {
                 if let Some(value) = attr.value.as_text() {
-                    self.offset_y = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.offset_y = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::OffsetX => {
                 if let Some(value) = attr.value.as_text() {
-                    self.offset_x = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.offset_x = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::MainAlign => {
@@ -135,26 +149,38 @@ impl ParseAttribute for LayoutState {
             }
             AttributeName::PositionTop => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_top(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_top(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionRight => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_right(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_right(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionBottom => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_bottom(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_bottom(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionLeft => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_left(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_left(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::Content => {
@@ -171,7 +197,11 @@ impl ParseAttribute for LayoutState {
             }
             AttributeName::Spacing => {
                 if let Some(value) = attr.value.as_text() {
-                    self.spacing = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.spacing = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             _ => {}
diff --git a/crates/state/src/lexing.rs b/crates/state/src/lexing.rs
new file mode 100644
index 000000000..8ee788c66
--- /dev/null
+++ b/crates/state/src/lexing.rs
@@ -0,0 +1,213 @@
+use std::{
+    fmt,
+    iter,
+};
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Token {
+    Ident(String),
+    Float(f32),
+    Integer(i64),
+    ParenOpen,
+    ParenClose,
+    Minus,
+    Plus,
+    Slash,
+    Star,
+    Pound,
+    Percent,
+    Comma,
+}
+
+impl Token {
+    pub fn ident<T: Into<String>>(value: T) -> Self {
+        Self::Ident(value.into())
+    }
+
+    pub fn is_ident(&self) -> bool {
+        matches!(self, Token::Ident(_))
+    }
+
+    pub fn is_f32(&self) -> bool {
+        matches!(self, Token::Float(_))
+    }
+
+    pub fn is_i64(&self) -> bool {
+        matches!(self, Token::Integer(_))
+    }
+
+    pub fn is_i64_or_f32(&self) -> bool {
+        matches!(self, Token::Integer(_) | Token::Float(_))
+    }
+
+    pub fn into_string(self) -> String {
+        if let Token::Ident(value) = self {
+            value
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn into_f32(self) -> f32 {
+        if let Token::Float(value) = self {
+            value
+        } else if let Token::Integer(value) = self {
+            value as f32
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn into_i64(self) -> i64 {
+        if let Token::Integer(value) = self {
+            value
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        if let Token::Ident(value) = self {
+            value.as_str()
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn try_as_str(&self) -> Option<&str> {
+        if let Token::Ident(value) = self {
+            Some(value.as_str())
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_f32(&self) -> Option<f32> {
+        if let Token::Float(value) = self {
+            Some(*value)
+        } else if let Token::Integer(value) = self {
+            Some(*value as f32)
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_i64(&self) -> Option<i64> {
+        if let Token::Integer(value) = self {
+            Some(*value)
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_u8(&self) -> Option<u8> {
+        if let Token::Integer(value) = self {
+            u8::try_from(*value).ok()
+        } else {
+            None
+        }
+    }
+}
+
+impl fmt::Display for Token {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Token::Ident(value) => f.write_str(value),
+            Token::Float(value) => write!(f, "float {value}"),
+            Token::Integer(value) => write!(f, "integer {value}"),
+            Token::ParenOpen => write!(f, "\"(\""),
+            Token::ParenClose => write!(f, "\")\""),
+            Token::Minus => write!(f, "\"-\""),
+            Token::Plus => write!(f, "\"+\""),
+            Token::Slash => write!(f, "\"/\""),
+            Token::Star => write!(f, "\"*\""),
+            Token::Pound => write!(f, "\"#\""),
+            Token::Percent => write!(f, "\"%\""),
+            Token::Comma => write!(f, "\",\""),
+        }
+    }
+}
+
+pub struct Lexer;
+
+impl Lexer {
+    pub fn parse<T: AsRef<str>>(data: T) -> Vec<Token> {
+        let mut tokens = vec![];
+        let mut chars = data.as_ref().chars().peekable();
+
+        while let Some(character) = chars.next() {
+            match character {
+                ' ' => continue,
+                'A'..='z' => {
+                    tokens.push(Token::Ident(
+                        iter::once(character)
+                            .chain(iter::from_fn(|| {
+                                chars
+                                    .by_ref()
+                                    .next_if(|s| s.is_ascii_alphanumeric() || s == &'-')
+                            }))
+                            .collect::<String>()
+                            .parse()
+                            .unwrap(),
+                    ));
+                }
+                '0'..='9' => {
+                    let value = iter::once(character)
+                        .chain(iter::from_fn(|| {
+                            chars.by_ref().next_if(|s| s.is_ascii_digit() || s == &'.')
+                        }))
+                        .collect::<String>();
+
+                    if value.contains('.') {
+                        tokens.push(Token::Float(value.parse().unwrap()));
+                    } else {
+                        tokens.push(Token::Integer(value.parse().unwrap()));
+                    }
+                }
+                '(' => tokens.push(Token::ParenOpen),
+                ')' => tokens.push(Token::ParenClose),
+                '+' => tokens.push(Token::Plus),
+                '-' => {
+                    if chars.peek().is_some_and(char::is_ascii_digit) {
+                        let value = iter::once(character)
+                            .chain(iter::from_fn(|| {
+                                chars.by_ref().next_if(|s| s.is_ascii_digit() || s == &'.')
+                            }))
+                            .collect::<String>();
+
+                        if value.contains('.') {
+                            tokens.push(Token::Float(value.parse().unwrap()));
+                        } else {
+                            tokens.push(Token::Integer(value.parse().unwrap()));
+                        }
+                    } else {
+                        tokens.push(Token::Minus);
+                    }
+                }
+                '*' => tokens.push(Token::Star),
+                '/' => tokens.push(Token::Slash),
+                '#' => {
+                    tokens.push(Token::Pound);
+
+                    if chars.peek().is_some_and(char::is_ascii_alphanumeric) {
+                        tokens.push(Token::Ident(
+                            iter::from_fn(|| chars.by_ref().next_if(char::is_ascii_alphanumeric))
+                                .collect::<String>(),
+                        ));
+                    }
+                }
+                '%' => tokens.push(Token::Percent),
+                ',' => tokens.push(Token::Comma),
+                character => {
+                    if let Some(Token::Ident(data)) = tokens.last_mut() {
+                        data.push(character);
+                    } else {
+                        tokens.push(Token::Ident(character.to_string()));
+                    }
+                }
+            }
+        }
+
+        tokens
+    }
+}
diff --git a/crates/state/src/lib.rs b/crates/state/src/lib.rs
index 4fae5a39a..1e713a84a 100644
--- a/crates/state/src/lib.rs
+++ b/crates/state/src/lib.rs
@@ -4,6 +4,7 @@ mod custom_attributes;
 mod font_style;
 mod layer;
 mod layout;
+mod lexing;
 mod parsing;
 mod references;
 mod style;
@@ -17,6 +18,7 @@ pub use custom_attributes::*;
 pub use font_style::*;
 pub use layer::*;
 pub use layout::*;
+pub use lexing::*;
 pub use parsing::*;
 pub use references::*;
 pub use style::*;
diff --git a/crates/state/src/parsing.rs b/crates/state/src/parsing.rs
index 20c022ac5..1c5ae02ba 100644
--- a/crates/state/src/parsing.rs
+++ b/crates/state/src/parsing.rs
@@ -1,183 +1,246 @@
-use std::str::CharIndices;
+use std::{
+    iter::Peekable,
+    ops::{
+        Bound,
+        RangeBounds,
+    },
+    vec::IntoIter,
+};
 
 use freya_native_core::prelude::OwnedAttributeView;
 
-use crate::CustomAttributeValues;
+use crate::{
+    CustomAttributeValues,
+    Lexer,
+    Token,
+};
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct ParseError;
+pub struct ParseError(pub String);
+
+impl ParseError {
+    pub fn expected_token(expected: &Token, found: Option<&Token>) -> Self {
+        if let Some(found) = found {
+            Self(format!("expected {expected}, found {found}"))
+        } else {
+            Self(format!("expected {expected}, found nothing"))
+        }
+    }
 
-// FromStr but we own it so we can impl it on torin and skia_safe types.
-pub trait Parse: Sized {
-    fn parse(value: &str) -> Result<Self, ParseError>;
-}
+    pub fn unexpected_token(value: Option<&Token>) -> Self {
+        if let Some(value) = value {
+            Self(format!("unexpected {value}"))
+        } else {
+            Self("unexpected nothing".into())
+        }
+    }
 
-pub trait ParseAttribute: Sized {
-    fn parse_attribute(
-        &mut self,
-        attr: OwnedAttributeView<CustomAttributeValues>,
-    ) -> Result<(), ParseError>;
+    pub fn invalid_ident(value: &str, expected: &[&str]) -> Self {
+        let expected = match expected.len() {
+            0 => "nothing".into(),
+            1 => expected[0].into(),
+            size => {
+                let other = expected[0..(size - 1)].join(", ");
+                let last = expected[size - 1];
 
-    fn parse_safe(&mut self, attr: OwnedAttributeView<CustomAttributeValues>) {
-        #[cfg(debug_assertions)]
-        {
-            let error_attr = attr.clone();
-            if self.parse_attribute(attr).is_err() {
-                panic!(
-                    "Failed to parse attribute '{:?}' with value '{:?}'",
-                    error_attr.attribute, error_attr.value
-                );
+                format!("{other} or {last}")
             }
-        }
+        };
 
-        #[cfg(not(debug_assertions))]
-        self.parse_attribute(attr).ok();
+        Self(format!("invalid ident {value} (expected {expected})"))
+    }
+
+    pub fn too_much_tokens(count: usize) -> Self {
+        Self(format!(
+            "found more than zero ({count}) tokens after parsing"
+        ))
     }
 }
 
-pub trait ExtSplit {
-    fn split_excluding_group(
-        &self,
-        delimiter: char,
-        group_start: char,
-        group_end: char,
-    ) -> SplitExcludingGroup<'_>;
-    fn split_ascii_whitespace_excluding_group(
-        &self,
-        group_start: char,
-        group_end: char,
-    ) -> SplitAsciiWhitespaceExcludingGroup<'_>;
+pub struct Parser {
+    pub(crate) tokens: Peekable<IntoIter<Token>>,
 }
 
-impl ExtSplit for str {
-    fn split_excluding_group(
-        &self,
-        delimiter: char,
-        group_start: char,
-        group_end: char,
-    ) -> SplitExcludingGroup<'_> {
-        SplitExcludingGroup {
-            text: self,
-            chars: self.char_indices(),
-            delimiter,
-            group_start,
-            group_end,
-            trailing_empty: true,
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Self {
+            tokens: tokens.into_iter().peekable(),
         }
     }
 
-    fn split_ascii_whitespace_excluding_group(
-        &self,
-        group_start: char,
-        group_end: char,
-    ) -> SplitAsciiWhitespaceExcludingGroup<'_> {
-        SplitAsciiWhitespaceExcludingGroup {
-            text: self,
-            chars: self.char_indices(),
-            group_start,
-            group_end,
+    /// Consumes the current token only if it exists and is equal to `value`.
+    pub fn try_consume(&mut self, value: &Token) -> bool {
+        if self.peek().is_some_and(|v| v == value) {
+            self.next();
+
+            true
+        } else {
+            false
         }
     }
-}
 
-#[derive(Clone, Debug)]
-pub struct SplitExcludingGroup<'a> {
-    pub text: &'a str,
-    pub chars: CharIndices<'a>,
-    pub delimiter: char,
-    pub group_start: char,
-    pub group_end: char,
-    pub trailing_empty: bool,
+    /// Checks if the next token exists and it is equal to `value`.
+    pub fn check(&mut self, value: &Token) -> bool {
+        self.peek().is_some_and(|v| v == value)
+    }
+
+    /// Returns the `bool` result of `func` if the next token exists.
+    pub fn check_if<F: Fn(&Token) -> bool>(&mut self, func: F) -> bool {
+        self.peek().is_some_and(func)
+    }
+
+    /// Consumes the current token if it exists and is equal to `value`, otherwise returning `ParseError`.
+    pub fn consume(&mut self, value: &Token) -> Result<Token, ParseError> {
+        if self.check(value) {
+            Ok(self.next().unwrap())
+        } else {
+            Err(ParseError::expected_token(value, self.peek()))
+        }
+    }
+
+    /// Consumes the current token if it exists and the result of `func` is `true`, otherwise returning `ParseError`.
+    pub fn consume_if<F: Fn(&Token) -> bool>(&mut self, func: F) -> Result<Token, ParseError> {
+        if self.check_if(func) {
+            Ok(self.next().unwrap())
+        } else {
+            Err(ParseError::unexpected_token(self.peek()))
+        }
+    }
+
+    /// Consumes the current token if it exists and the result of the `func` is `Some(T)`, otherwise returning `ParseError`.
+    pub fn consume_map<T, F: Fn(&Token) -> Option<T>>(&mut self, func: F) -> Result<T, ParseError> {
+        if let Some(value) = self.peek().and_then(func) {
+            self.next();
+
+            Ok(value)
+        } else {
+            Err(ParseError::unexpected_token(self.peek()))
+        }
+    }
+
+    /// Consumes the current token and returns it wrapped in `Some` if it exists, otherwise returning `None`.
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&mut self) -> Option<Token> {
+        self.tokens.next()
+    }
+
+    /// Peeks the current token and returns a reference to it wrapped in `Some` if it exists, otherwise returning `None`.
+    pub fn peek(&mut self) -> Option<&Token> {
+        self.tokens.peek()
+    }
 }
 
-impl<'a> Iterator for SplitExcludingGroup<'a> {
-    type Item = &'a str;
+// FromStr but we own it so we can impl it on torin and skia_safe types.
+pub trait Parse: Sized {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError>;
+    fn from_parser_multiple(
+        parser: &mut Parser,
+        separator: &Token,
+    ) -> Result<Vec<Self>, ParseError> {
+        let mut values = vec![Self::from_parser(parser)?];
+
+        while parser.try_consume(separator) {
+            values.push(Self::from_parser(parser)?);
+        }
 
-    fn next(&mut self) -> Option<&'a str> {
-        let first = self.chars.next();
+        Ok(values)
+    }
 
-        let (start, mut prev) = match first {
-            None => {
-                if self.text.ends_with(self.delimiter) && self.trailing_empty {
-                    self.trailing_empty = false;
-                    return Some("");
-                }
-                return None;
-            }
-            Some((_, c)) if c == self.delimiter => return Some(""),
-            Some(v) => v,
-        };
+    fn parse_with_separator(value: &str, separator: &Token) -> Result<Vec<Self>, ParseError> {
+        let mut parser = Parser::new(Lexer::parse(value));
 
-        let mut in_group = false;
-        let mut nesting = -1;
-
-        loop {
-            if prev == self.group_start {
-                if nesting == -1 {
-                    in_group = true;
-                }
-                nesting += 1;
-            } else if prev == self.group_end {
-                nesting -= 1;
-                if nesting == -1 {
-                    in_group = false;
-                }
-            }
+        let values = Self::from_parser_multiple(&mut parser, separator)?;
 
-            prev = match self.chars.next() {
-                None => return Some(&self.text[start..]),
-                Some((end, c)) if c == self.delimiter && !in_group => {
-                    return Some(&self.text[start..end])
-                }
-                Some((_, c)) => c,
-            }
+        if parser.tokens.len() > 0 {
+            Err(ParseError::too_much_tokens(parser.tokens.len()))
+        } else {
+            Ok(values)
+        }
+    }
+
+    fn parse(value: &str) -> Result<Self, ParseError> {
+        let mut parser = Parser::new(Lexer::parse(value));
+
+        let value = Self::from_parser(&mut parser);
+
+        if parser.tokens.len() > 0 {
+            Err(ParseError::too_much_tokens(parser.tokens.len()))
+        } else {
+            value
         }
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct SplitAsciiWhitespaceExcludingGroup<'a> {
-    pub text: &'a str,
-    pub chars: CharIndices<'a>,
-    pub group_start: char,
-    pub group_end: char,
+pub fn parse_angle(parser: &mut Parser) -> Result<f32, ParseError> {
+    let value = parser.consume_map(Token::try_as_i64)?;
+
+    parser.consume(&Token::ident("deg"))?;
+
+    Ok((value % 360) as f32)
 }
 
-impl<'a> Iterator for SplitAsciiWhitespaceExcludingGroup<'a> {
-    type Item = &'a str;
+pub fn parse_range(parser: &mut Parser, range: impl RangeBounds<i64>) -> Result<f32, ParseError> {
+    let value = parser.consume_map(Token::try_as_i64)?;
 
-    fn next(&mut self) -> Option<&'a str> {
-        let first = self.chars.next();
+    if range.contains(&value) {
+        Ok(value as f32)
+    } else {
+        let start = match range.start_bound() {
+            Bound::Included(value) => Some(format!("greater than or equal to {value}")),
+            _ => None,
+        };
 
-        let (start, mut prev) = match first {
-            None => return None,
-            Some((_, c)) if c.is_ascii_whitespace() => return self.next(),
-            Some(v) => v,
+        let end = match range.end_bound() {
+            Bound::Included(value) => Some(format!("less than or equal to {value}")),
+            Bound::Excluded(value) => Some(format!("less than {value}")),
+            Bound::Unbounded => None,
         };
 
-        let mut in_group = false;
-        let mut nesting = -1;
-
-        loop {
-            if prev == self.group_start {
-                if nesting == -1 {
-                    in_group = true;
-                }
-                nesting += 1;
-            } else if prev == self.group_end {
-                nesting -= 1;
-                if nesting == -1 {
-                    in_group = false;
-                }
-            }
+        Err(match [start, end] {
+            [Some(start), Some(end)] => ParseError(format!("{value} must be {start} and {end}")),
+            [Some(start), None] => ParseError(format!("{value} must be {start}")),
+            [None, Some(end)] => ParseError(format!("{value} must be {end}")),
+            [None, None] => unreachable!(),
+        })
+    }
+}
+
+pub fn parse_func<T: AsRef<str>, F: FnOnce(&mut Parser) -> Result<O, ParseError>, O>(
+    parser: &mut Parser,
+    name: T,
+    body: F,
+) -> Result<O, ParseError> {
+    parser.consume(&Token::ident(name.as_ref()))?;
+
+    parser.consume(&Token::ParenOpen)?;
 
-            prev = match self.chars.next() {
-                None => return Some(&self.text[start..]),
-                Some((end, c)) if c.is_ascii_whitespace() && !in_group => {
-                    return Some(&self.text[start..end])
-                }
-                Some((_, c)) => c,
+    let value = body(parser)?;
+
+    parser.consume(&Token::ParenClose)?;
+
+    Ok(value)
+}
+
+pub trait ParseAttribute: Sized {
+    fn parse_attribute(
+        &mut self,
+        attr: OwnedAttributeView<CustomAttributeValues>,
+    ) -> Result<(), ParseError>;
+
+    fn parse_safe(&mut self, attr: OwnedAttributeView<CustomAttributeValues>) {
+        #[cfg(debug_assertions)]
+        {
+            let error_attr = attr.clone();
+
+            if let Err(ParseError(message)) = self.parse_attribute(attr) {
+                panic!(
+                    "Failed to parse attribute '{:?}' with value '{:?}': {message}",
+                    error_attr.attribute, error_attr.value
+                );
             }
         }
+
+        #[cfg(not(debug_assertions))]
+        self.parse_attribute(attr).ok();
     }
 }
diff --git a/crates/state/src/style.rs b/crates/state/src/style.rs
index 978a57162..0dd24cb3f 100644
--- a/crates/state/src/style.rs
+++ b/crates/state/src/style.rs
@@ -20,17 +20,18 @@ use freya_native_core::{
 use freya_native_core_macro::partial_derive_state;
 
 use crate::{
-    parsing::ExtSplit,
     AttributesBytes,
     Border,
     CornerRadius,
     CustomAttributeValues,
     Fill,
+    Lexer,
     OverflowMode,
     Parse,
     ParseAttribute,
-    ParseError,
+    Parser,
     Shadow,
+    Token,
 };
 
 #[derive(Default, Debug, Clone, PartialEq, Component)]
@@ -55,41 +56,38 @@ impl ParseAttribute for StyleState {
                     if value == "none" {
                         return Ok(());
                     }
+
                     self.background = Fill::parse(value)?;
                 }
             }
             AttributeName::Border => {
                 if let Some(value) = attr.value.as_text() {
-                    self.borders = value
-                        .split_excluding_group(',', '(', ')')
-                        .map(|chunk| Border::parse(chunk).unwrap_or_default())
-                        .collect();
+                    self.borders = Border::parse_with_separator(value, &Token::Comma)?;
                 }
             }
             AttributeName::Shadow => {
                 if let Some(value) = attr.value.as_text() {
-                    self.shadows = value
-                        .split_excluding_group(',', '(', ')')
-                        .map(|chunk| Shadow::parse(chunk).unwrap_or_default())
-                        .collect();
+                    self.shadows = Shadow::parse_with_separator(value, &Token::Comma)?;
                 }
             }
             AttributeName::CornerRadius => {
                 if let Some(value) = attr.value.as_text() {
                     let mut radius = CornerRadius::parse(value)?;
+
                     radius.smoothing = self.corner_radius.smoothing;
+
                     self.corner_radius = radius;
                 }
             }
             AttributeName::CornerSmoothing => {
                 if let Some(value) = attr.value.as_text() {
-                    if value.ends_with('%') {
-                        let smoothing = value
-                            .replacen('%', "", 1)
-                            .parse::<f32>()
-                            .map_err(|_| ParseError)?;
-                        self.corner_radius.smoothing = (smoothing / 100.0).clamp(0.0, 1.0);
-                    }
+                    let mut parser = Parser::new(Lexer::parse(value));
+
+                    let smoothing = parser.consume_map(Token::try_as_f32)?;
+
+                    parser.consume(&Token::Percent)?;
+
+                    self.corner_radius.smoothing = (smoothing / 100.0).clamp(0.0, 1.0);
                 }
             }
             AttributeName::ImageData => {
diff --git a/crates/state/src/transform.rs b/crates/state/src/transform.rs
index 2d0569722..4967fbde5 100644
--- a/crates/state/src/transform.rs
+++ b/crates/state/src/transform.rs
@@ -41,18 +41,17 @@ impl ParseAttribute for TransformState {
         match attr.attribute {
             AttributeName::Rotate => {
                 if let Some(value) = attr.value.as_text() {
-                    if value.ends_with("deg") {
-                        let rotation = value
-                            .replacen("deg", "", 1)
-                            .parse::<f32>()
-                            .map_err(|_| ParseError)?;
-                        self.rotations.push((self.node_id, rotation));
-                    }
+                    let mut parser = crate::Parser::new(crate::Lexer::parse(value));
+
+                    self.rotations
+                        .push((self.node_id, crate::parse_angle(&mut parser)?));
                 }
             }
             AttributeName::Opacity => {
                 if let Some(value) = attr.value.as_text() {
-                    let opacity = value.parse::<f32>().map_err(|_| ParseError)?;
+                    let opacity = value
+                        .parse::<f32>()
+                        .map_err(|err| ParseError(err.to_string()))?;
                     self.opacities.push(opacity)
                 }
             }
diff --git a/crates/state/src/values/alignment.rs b/crates/state/src/values/alignment.rs
index 93e4d5820..066d28727 100644
--- a/crates/state/src/values/alignment.rs
+++ b/crates/state/src/values/alignment.rs
@@ -3,17 +3,21 @@ use torin::alignment::Alignment;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 impl Parse for Alignment {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "center" => Alignment::Center,
-            "end" => Alignment::End,
-            "space-between" => Alignment::SpaceBetween,
-            "space-evenly" => Alignment::SpaceEvenly,
-            "space-around" => Alignment::SpaceAround,
-            _ => Alignment::Start,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "start" => Some(Self::Start),
+                "center" => Some(Self::Center),
+                "end" => Some(Self::End),
+                "space-between" => Some(Self::SpaceBetween),
+                "space-evenly" => Some(Self::SpaceEvenly),
+                "space-around" => Some(Self::SpaceAround),
+                _ => None,
+            })
         })
     }
 }
diff --git a/crates/state/src/values/border.rs b/crates/state/src/values/border.rs
index 5ed6939d1..89a86e3d2 100644
--- a/crates/state/src/values/border.rs
+++ b/crates/state/src/values/border.rs
@@ -4,10 +4,11 @@ use freya_engine::prelude::Color;
 use torin::scaled::Scaled;
 
 use crate::{
-    ExtSplit,
     Fill,
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 #[derive(Default, Clone, Debug, PartialEq)]
@@ -36,6 +37,44 @@ pub struct BorderWidth {
     pub left: f32,
 }
 
+impl Parse for BorderWidth {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        Ok(
+            match (
+                parser.consume_map(Token::try_as_f32)?,
+                parser.consume_map(Token::try_as_f32).ok(),
+                parser.consume_map(Token::try_as_f32).ok(),
+                parser.consume_map(Token::try_as_f32).ok(),
+            ) {
+                (top, Some(right), Some(bottom), Some(left)) => Self {
+                    top,
+                    right,
+                    bottom,
+                    left,
+                },
+                (top, Some(horizontal), Some(bottom), _) => Self {
+                    top,
+                    right: horizontal,
+                    bottom,
+                    left: horizontal,
+                },
+                (vertical, Some(horizontal), ..) => Self {
+                    top: vertical,
+                    right: horizontal,
+                    bottom: vertical,
+                    left: horizontal,
+                },
+                (all, ..) => Self {
+                    top: all,
+                    right: all,
+                    bottom: all,
+                    left: all,
+                },
+            },
+        )
+    }
+}
+
 impl Scaled for BorderWidth {
     fn scale(&mut self, scale_factor: f32) {
         self.top *= scale_factor;
@@ -64,12 +103,14 @@ pub enum BorderAlignment {
 }
 
 impl Parse for BorderAlignment {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "inner" => BorderAlignment::Inner,
-            "outer" => BorderAlignment::Outer,
-            "center" => BorderAlignment::Center,
-            _ => BorderAlignment::default(),
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "inner" => Some(BorderAlignment::Inner),
+                "outer" => Some(BorderAlignment::Outer),
+                "center" => Some(BorderAlignment::Center),
+                _ => None,
+            })
         })
     }
 }
@@ -85,126 +126,22 @@ impl fmt::Display for BorderAlignment {
 }
 
 impl Parse for Border {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        if value == "none" {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        if parser.try_consume(&Token::ident("none")) {
             return Ok(Self::default());
         }
 
-        let mut border_values = value.split_ascii_whitespace_excluding_group('(', ')');
-
-        Ok(match border_values.clone().count() {
-            // <width> <style> <fill>
-            3 => {
-                let width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-
-                Border {
-                    width: BorderWidth {
-                        top: width,
-                        left: width,
-                        bottom: width,
-                        right: width,
-                    },
-                    alignment: BorderAlignment::parse(border_values.next().ok_or(ParseError)?)?,
-                    fill: Fill::parse(&border_values.collect::<Vec<&str>>().join(" "))
-                        .map_err(|_| ParseError)?,
-                }
-            }
-
-            // <vertical> <horizontal> <solid> <fill>
-            4 => {
-                let vertical_width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-                let horizontal_width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-
-                Border {
-                    width: BorderWidth {
-                        top: vertical_width,
-                        left: horizontal_width,
-                        bottom: vertical_width,
-                        right: horizontal_width,
-                    },
-                    alignment: BorderAlignment::parse(border_values.next().ok_or(ParseError)?)?,
-                    fill: Fill::parse(&border_values.collect::<Vec<&str>>().join(" "))
-                        .map_err(|_| ParseError)?,
-                }
-            }
-            // <top> <horizontal> <bottom> <style> <fill>
-            5 => {
-                let top_width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-                let horizontal_width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-                let bottom_width = border_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-
-                Border {
-                    width: BorderWidth {
-                        top: top_width,
-                        left: horizontal_width,
-                        bottom: bottom_width,
-                        right: horizontal_width,
-                    },
-                    alignment: BorderAlignment::parse(border_values.next().ok_or(ParseError)?)?,
-                    fill: Fill::parse(&border_values.collect::<Vec<&str>>().join(" "))
-                        .map_err(|_| ParseError)?,
-                }
-            }
-            // <top> <right> <bottom> <left> <style> <fill>
-            6 => Border {
-                width: BorderWidth {
-                    top: border_values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    right: border_values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    bottom: border_values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    left: border_values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                },
-                alignment: BorderAlignment::parse(border_values.next().ok_or(ParseError)?)?,
-                fill: Fill::parse(&border_values.collect::<Vec<&str>>().join(" "))
-                    .map_err(|_| ParseError)?,
-            },
-            _ => return Err(ParseError),
+        Ok(Border {
+            width: BorderWidth::from_parser(parser)?,
+            alignment: BorderAlignment::from_parser(parser)?,
+            fill: Fill::from_parser(parser)?,
         })
     }
 }
 
 impl fmt::Display for Border {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {} {}", self.width, self.alignment, self.fill,)
+        write!(f, "{} {} {}", self.width, self.alignment, self.fill)
     }
 }
 
diff --git a/crates/state/src/values/color.rs b/crates/state/src/values/color.rs
index f14682516..6447cdcc2 100644
--- a/crates/state/src/values/color.rs
+++ b/crates/state/src/values/color.rs
@@ -3,8 +3,13 @@ use std::fmt;
 use freya_engine::prelude::*;
 
 use crate::{
+    parse_angle,
+    parse_func,
+    parse_range,
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 pub trait DisplayColor {
@@ -13,27 +18,35 @@ pub trait DisplayColor {
 }
 
 impl Parse for Color {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        match value {
-            "red" => Ok(Color::RED),
-            "green" => Ok(Color::GREEN),
-            "blue" => Ok(Color::BLUE),
-            "yellow" => Ok(Color::YELLOW),
-            "black" => Ok(Color::BLACK),
-            "gray" => Ok(Color::GRAY),
-            "white" => Ok(Color::WHITE),
-            "orange" => Ok(Color::from_rgb(255, 165, 0)),
-            "transparent" | "none" => Ok(Color::TRANSPARENT),
-            _ => {
-                if value.starts_with("hsl(") {
-                    parse_hsl(value)
-                } else if value.starts_with("rgb(") {
-                    parse_rgb(value)
-                } else if value.starts_with('#') {
-                    parse_hex_color(value)
-                } else {
-                    Err(ParseError)
-                }
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        if parser.check(&Token::Pound) {
+            parse_hex_color(parser)
+        } else if parser.check(&Token::ident("rgb")) {
+            parse_rgb(parser)
+        } else if parser.check(&Token::ident("hsl")) {
+            parse_hsl(parser)
+        } else {
+            let value = parser.consume_if(Token::is_ident).map(Token::into_string)?;
+
+            match value.as_str() {
+                "red" => Ok(Color::RED),
+                "green" => Ok(Color::GREEN),
+                "blue" => Ok(Color::BLUE),
+                "yellow" => Ok(Color::YELLOW),
+                "black" => Ok(Color::BLACK),
+                "gray" => Ok(Color::GRAY),
+                "white" => Ok(Color::WHITE),
+                "orange" => Ok(Color::from_rgb(255, 165, 0)),
+                "transparent" | "none" => Ok(Color::TRANSPARENT),
+                value => Err(ParseError::invalid_ident(
+                    value,
+                    &[
+                        "hex color",
+                        "built-in color name",
+                        "color functions",
+                        "none",
+                    ],
+                )),
             }
         }
     }
@@ -72,127 +85,101 @@ impl DisplayColor for Color {
     }
 }
 
-fn parse_rgb(color: &str) -> Result<Color, ParseError> {
-    if !color.ends_with(')') {
-        return Err(ParseError);
-    }
+fn parse_rgb(parser: &mut Parser) -> Result<Color, ParseError> {
+    parse_func(parser, "rgb", |parser| {
+        let red = parser.consume_map(Token::try_as_u8)?;
 
-    let color = color.replacen("rgb(", "", 1).replacen(')', "", 1);
-
-    let mut colors = color.split(',');
-
-    let r = colors
-        .next()
-        .ok_or(ParseError)?
-        .trim()
-        .parse::<u8>()
-        .map_err(|_| ParseError)?;
-    let g = colors
-        .next()
-        .ok_or(ParseError)?
-        .trim()
-        .parse::<u8>()
-        .map_err(|_| ParseError)?;
-    let b = colors
-        .next()
-        .ok_or(ParseError)?
-        .trim()
-        .parse::<u8>()
-        .map_err(|_| ParseError)?;
-    let a: Option<&str> = colors.next();
-
-    // There should not be more than 4 components.
-    if colors.next().is_some() {
-        return Err(ParseError);
-    }
+        parser.consume(&Token::Comma)?;
+
+        let green = parser.consume_map(Token::try_as_u8)?;
+
+        parser.consume(&Token::Comma)?;
 
-    if let Some(a) = a {
-        let alpha_trimmed = a.trim();
-        if let Ok(u8_alpha) = alpha_trimmed.parse::<u8>() {
-            Ok(Color::from_argb(u8_alpha, r, g, b))
-        } else if let Ok(f32_alpha) = alpha_trimmed.parse::<f32>() {
-            let a = (255.0 * f32_alpha).clamp(0.0, 255.0).round() as u8;
-            Ok(Color::from_argb(a, r, g, b))
+        let blue = parser.consume_map(Token::try_as_u8)?;
+
+        Ok(if parser.try_consume(&Token::Comma) {
+            let alpha = if let Ok(value) = parser.consume_if(Token::is_f32).map(Token::into_f32) {
+                (value * 255.0).round() as u8
+            } else {
+                parser.consume_map(Token::try_as_u8)?
+            };
+
+            Color::from_argb(alpha, red, green, blue)
         } else {
-            Err(ParseError)
-        }
-    } else {
-        Ok(Color::from_rgb(r, g, b))
-    }
+            Color::from_rgb(red, green, blue)
+        })
+    })
 }
 
-fn parse_hsl(color: &str) -> Result<Color, ParseError> {
-    if !color.ends_with(')') {
-        return Err(ParseError);
-    }
+fn parse_hsl(parser: &mut Parser) -> Result<Color, ParseError> {
+    parse_func(parser, "hsl", |parser| {
+        let h = parse_angle(parser)?;
 
-    let color = color.replacen("hsl(", "", 1).replacen(')', "", 1);
-    let mut colors = color.split(',');
-
-    // Get each color component as a string
-    let h_str = colors.next().ok_or(ParseError)?.trim();
-    let s_str = colors.next().ok_or(ParseError)?.trim();
-    let l_str = colors.next().ok_or(ParseError)?.trim();
-    let a_str: Option<&str> = colors.next();
-
-    // Ensure correct units and lengths.
-    if colors.next().is_some()
-        || !h_str.ends_with("deg")
-        || !s_str.ends_with('%')
-        || !l_str.ends_with('%')
-    {
-        return Err(ParseError);
-    }
+        parser.consume(&Token::Comma)?;
 
-    // S, L and A can end in percentage, otherwise its 0.0 - 1.0
-    let h = h_str
-        .replacen("deg", "", 1)
-        .parse::<f32>()
-        .map_err(|_| ParseError)?;
-    let mut s = s_str
-        .replacen('%', "", 1)
-        .parse::<f32>()
-        .map_err(|_| ParseError)?
-        / 100.0;
-    let mut l = l_str
-        .replacen('%', "", 1)
-        .parse::<f32>()
-        .map_err(|_| ParseError)?
-        / 100.0;
-
-    // HSL to HSV Conversion
-    l *= 2.0;
-    s *= if l <= 1.0 { l } else { 2.0 - l };
-    let v = (l + s) / 2.0;
-    s = (2.0 * s) / (l + s);
-    let hsv = HSV::from((h, s, v));
-
-    // Handle alpha formatting and convert to ARGB
-    if let Some(a_str) = a_str {
-        if !s_str.ends_with('%') {
-            return Err(ParseError);
-        }
+        let mut s = parse_range(parser, 0..=100)?;
 
-        let a = a_str
-            .trim()
-            .replace('%', "")
-            .parse::<f32>()
-            .map_err(|_| ParseError)?
-            / 100.0;
+        parser.consume(&Token::Percent)?;
+        parser.consume(&Token::Comma)?;
 
-        Ok(hsv.to_color((a * 255.0).round() as u8))
-    } else {
-        Ok(hsv.to_color(255))
-    }
+        let mut l = parse_range(parser, 0..=100)?;
+
+        parser.consume(&Token::Percent)?;
+
+        let a = if parser.try_consume(&Token::Comma) {
+            let value = parse_range(parser, 0..=100)?;
+
+            parser.consume(&Token::Percent)?;
+
+            Some(value)
+        } else {
+            None
+        };
+
+        // HSL to HSV Conversion
+        l *= 2.0;
+        s *= if l <= 1.0 { l } else { 2.0 - l };
+
+        let v = (l + s) / 2.0;
+
+        s = (2.0 * s) / (l + s);
+
+        let hsv = HSV::from((h, s, v));
+
+        // Handle alpha formatting and convert to ARGB
+        Ok(a.map(|a| hsv.to_color((a * 255.0).round() as u8))
+            .unwrap_or_else(|| hsv.to_color(255)))
+    })
 }
 
-fn parse_hex_color(color: &str) -> Result<Color, ParseError> {
-    if color.len() == 7 {
-        let r = u8::from_str_radix(&color[1..3], 16).map_err(|_| ParseError)?;
-        let g = u8::from_str_radix(&color[3..5], 16).map_err(|_| ParseError)?;
-        let b = u8::from_str_radix(&color[5..7], 16).map_err(|_| ParseError)?;
-        Ok(Color::from_rgb(r, g, b))
-    } else {
-        Err(ParseError)
+fn parse_hex_color(parser: &mut Parser) -> Result<Color, ParseError> {
+    parser.consume(&Token::Pound)?;
+
+    let hex = parser.consume_if(Token::is_ident).map(Token::into_string)?;
+
+    if ![6, 8].contains(&hex.len()) {
+        return Err(ParseError("invalid hex color".into()));
     }
+
+    let value =
+        i64::from_str_radix(&hex, 16).map_err(|_| ParseError("invalid hex color".into()))?;
+
+    let a = if hex.len() == 8 {
+        Some(
+            u8::try_from((value >> 24) & 0xFF)
+                .map_err(|_| ParseError("failed to parse hex color part as u8".into()))?,
+        )
+    } else {
+        None
+    };
+
+    let r = u8::try_from((value >> 16) & 0xFF)
+        .map_err(|_| ParseError("failed to parse hex color part as u8".into()))?;
+    let g = u8::try_from((value >> 8) & 0xFF)
+        .map_err(|_| ParseError("failed to parse hex color part as u8".into()))?;
+    let b = u8::try_from(value & 0xFF)
+        .map_err(|_| ParseError("failed to parse hex color part as u8".into()))?;
+
+    Ok(a.map(|a| Color::from_argb(a, r, g, b))
+        .unwrap_or_else(|| Color::from_rgb(r, g, b)))
 }
diff --git a/crates/state/src/values/content.rs b/crates/state/src/values/content.rs
index 7cd26f0a1..50bc6c4af 100644
--- a/crates/state/src/values/content.rs
+++ b/crates/state/src/values/content.rs
@@ -3,13 +3,17 @@ use torin::content::Content;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 impl Parse for Content {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "fit" => Content::Fit,
-            _ => Content::Normal,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "normal" => Some(Self::Normal),
+                "fit" => Some(Self::Fit),
+                _ => None,
+            })
         })
     }
 }
diff --git a/crates/state/src/values/corner_radius.rs b/crates/state/src/values/corner_radius.rs
index 004a6afab..f58e75555 100644
--- a/crates/state/src/values/corner_radius.rs
+++ b/crates/state/src/values/corner_radius.rs
@@ -9,6 +9,8 @@ use torin::scaled::Scaled;
 use crate::{
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 #[derive(PartialEq, Clone, Debug, Default, Copy)]
@@ -199,68 +201,42 @@ impl CornerRadius {
 }
 
 impl Parse for CornerRadius {
-    fn parse(value: &str) -> Result<Self, ParseError> {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
         let mut radius = CornerRadius::default();
-        let mut values = value.split_ascii_whitespace();
 
-        match values.clone().count() {
-            // Same in all corners
-            1 => {
-                radius.fill_all(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                );
+        match (
+            parser.consume_map(Token::try_as_f32)?,
+            parser.consume_map(Token::try_as_f32).ok(),
+            parser.consume_map(Token::try_as_f32).ok(),
+            parser.consume_map(Token::try_as_f32).ok(),
+        ) {
+            // Each corner
+            (top_left, Some(top_right), Some(bottom_left), Some(bottom_right)) => {
+                radius = CornerRadius {
+                    top_left,
+                    top_right,
+                    bottom_left,
+                    bottom_right,
+                    ..Default::default()
+                }
             }
             // By Top and Bottom
-            2 => {
+            (top, Some(bottom), None, None) => {
                 // Top
-                radius.fill_top(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                );
+                radius.fill_top(top);
 
                 // Bottom
-                radius.fill_bottom(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                )
+                radius.fill_bottom(bottom)
             }
-            // Each corner
-            4 => {
-                radius = CornerRadius {
-                    top_left: values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    top_right: values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    bottom_left: values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    bottom_right: values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    ..Default::default()
-                }
+            // Same in all corners
+            (value, None, None, None) => {
+                radius.fill_all(value);
+            }
+            _ => {
+                return Err(ParseError(
+                    "invalid count of numbers (must be 1, 2 or 4)".into(),
+                ))
             }
-            _ => return Err(ParseError),
         }
 
         Ok(radius)
diff --git a/crates/state/src/values/cursor.rs b/crates/state/src/values/cursor.rs
index f91a45ee7..63901add3 100644
--- a/crates/state/src/values/cursor.rs
+++ b/crates/state/src/values/cursor.rs
@@ -3,6 +3,7 @@ use std::fmt;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -12,10 +13,13 @@ pub enum CursorMode {
 }
 
 impl Parse for CursorMode {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "editable" => CursorMode::Editable,
-            _ => CursorMode::None,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "none" => Some(Self::None),
+                "editable" => Some(Self::Editable),
+                _ => None,
+            })
         })
     }
 }
diff --git a/crates/state/src/values/decoration.rs b/crates/state/src/values/decoration.rs
index b049bdba3..5a8395beb 100644
--- a/crates/state/src/values/decoration.rs
+++ b/crates/state/src/values/decoration.rs
@@ -3,23 +3,23 @@ use freya_engine::prelude::*;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 impl Parse for TextDecoration {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        let mut decoration = TextDecoration::default();
-        let values = value.split_ascii_whitespace();
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        let mut decoration = Self::default();
 
-        for val in values {
-            decoration.set(
-                match val {
-                    "underline" => TextDecoration::UNDERLINE,
-                    "overline" => TextDecoration::OVERLINE,
-                    "line-through" => TextDecoration::LINE_THROUGH,
-                    _ => TextDecoration::NO_DECORATION,
-                },
-                true,
-            );
+        while let Ok(value) = parser.consume_map(|token| {
+            token.try_as_str().and_then(|value| match value {
+                "none" => Some(Self::NO_DECORATION),
+                "underline" => Some(Self::UNDERLINE),
+                "overline" => Some(Self::OVERLINE),
+                "line-through" => Some(Self::LINE_THROUGH),
+                _ => None,
+            })
+        }) {
+            decoration.set(value, true);
         }
 
         Ok(decoration)
@@ -27,14 +27,16 @@ impl Parse for TextDecoration {
 }
 
 impl Parse for TextDecorationStyle {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "solid" => TextDecorationStyle::Solid,
-            "double" => TextDecorationStyle::Double,
-            "dotted" => TextDecorationStyle::Dotted,
-            "dashed" => TextDecorationStyle::Dashed,
-            "wavy" => TextDecorationStyle::Wavy,
-            _ => TextDecorationStyle::Solid,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|token| {
+            token.try_as_str().and_then(|value| match value {
+                "solid" => Some(Self::Solid),
+                "double" => Some(Self::Double),
+                "dotted" => Some(Self::Dotted),
+                "dashed" => Some(Self::Dashed),
+                "wavy" => Some(Self::Wavy),
+                _ => None,
+            })
         })
     }
 }
diff --git a/crates/state/src/values/fill.rs b/crates/state/src/values/fill.rs
index 84556f517..bcaa1e85e 100644
--- a/crates/state/src/values/fill.rs
+++ b/crates/state/src/values/fill.rs
@@ -12,7 +12,9 @@ use crate::{
     LinearGradient,
     Parse,
     ParseError,
+    Parser,
     RadialGradient,
+    Token,
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -55,16 +57,16 @@ impl From<Color> for Fill {
 }
 
 impl Parse for Fill {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(if value.starts_with("linear-gradient(") {
-            Self::LinearGradient(LinearGradient::parse(value).map_err(|_| ParseError)?)
-        } else if value.starts_with("radial-gradient(") {
-            Self::RadialGradient(RadialGradient::parse(value).map_err(|_| ParseError)?)
-        } else if value.starts_with("conic-gradient(") {
-            Self::ConicGradient(ConicGradient::parse(value).map_err(|_| ParseError)?)
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        if parser.check(&Token::ident("linear-gradient")) {
+            LinearGradient::from_parser(parser).map(Self::LinearGradient)
+        } else if parser.check(&Token::ident("radial-gradient")) {
+            RadialGradient::from_parser(parser).map(Self::RadialGradient)
+        } else if parser.check(&Token::ident("gradient-gradient")) {
+            ConicGradient::from_parser(parser).map(Self::ConicGradient)
         } else {
-            Self::Color(Color::parse(value).map_err(|_| ParseError)?)
-        })
+            Color::from_parser(parser).map(Self::Color)
+        }
     }
 }
 
diff --git a/crates/state/src/values/focusable.rs b/crates/state/src/values/focusable.rs
index 8f4e8d9c2..d32f3b00a 100644
--- a/crates/state/src/values/focusable.rs
+++ b/crates/state/src/values/focusable.rs
@@ -1,6 +1,7 @@
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 #[derive(Clone, Debug, PartialEq, Default, Eq)]
@@ -22,6 +23,10 @@ impl Focusable {
 }
 
 impl Parse for Focusable {
+    fn from_parser(_: &mut Parser) -> Result<Self, ParseError> {
+        unimplemented!()
+    }
+
     fn parse(value: &str) -> Result<Self, ParseError> {
         Ok(match value {
             "true" => Self::Enabled,
diff --git a/crates/state/src/values/font.rs b/crates/state/src/values/font.rs
index 673e08732..887246e8c 100644
--- a/crates/state/src/values/font.rs
+++ b/crates/state/src/values/font.rs
@@ -3,46 +3,53 @@ use freya_engine::prelude::*;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 impl Parse for TextAlign {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "center" => TextAlign::Center,
-            "justify" => TextAlign::Justify,
-            "start" => TextAlign::Start,
-            "end" => TextAlign::End,
-            "left" => TextAlign::Left,
-            "right" => TextAlign::Right,
-            _ => TextAlign::default(),
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|token| {
+            token.try_as_str().and_then(|value| match value {
+                "center" => Some(TextAlign::Center),
+                "justify" => Some(TextAlign::Justify),
+                "start" => Some(TextAlign::Start),
+                "end" => Some(TextAlign::End),
+                "left" => Some(TextAlign::Left),
+                "right" => Some(TextAlign::Right),
+                _ => None,
+            })
         })
     }
 }
 
 impl Parse for Slant {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "upright" => Slant::Upright,
-            "italic" => Slant::Italic,
-            "oblique" => Slant::Oblique,
-            _ => Slant::Upright,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|token| {
+            token.try_as_str().and_then(|value| match value {
+                "upright" | "normal" => Some(Slant::Upright),
+                "italic" => Some(Slant::Italic),
+                "oblique" => Some(Slant::Oblique),
+                _ => None,
+            })
         })
     }
 }
 
 impl Parse for Width {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "ultra-condensed" => Width::ULTRA_CONDENSED,
-            "extra-condensed" => Width::EXTRA_CONDENSED,
-            "condensed" => Width::CONDENSED,
-            "semi-condensed" => Width::SEMI_CONDENSED,
-            "normal" => Width::NORMAL,
-            "semi-expanded" => Width::SEMI_EXPANDED,
-            "expanded" => Width::EXPANDED,
-            "extra-expanded" => Width::EXTRA_EXPANDED,
-            "ultra-expanded" => Width::ULTRA_EXPANDED,
-            _ => Width::NORMAL,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|token| {
+            token.try_as_str().and_then(|value| match value {
+                "ultra-condensed" => Some(Width::ULTRA_CONDENSED),
+                "extra-condensed" => Some(Width::EXTRA_CONDENSED),
+                "condensed" => Some(Width::CONDENSED),
+                "semi-condensed" => Some(Width::SEMI_CONDENSED),
+                "normal" => Some(Width::NORMAL),
+                "semi-expanded" => Some(Width::SEMI_EXPANDED),
+                "expanded" => Some(Width::EXPANDED),
+                "extra-expanded" => Some(Width::EXTRA_EXPANDED),
+                "ultra-expanded" => Some(Width::ULTRA_EXPANDED),
+                _ => None,
+            })
         })
     }
 }
@@ -53,31 +60,39 @@ impl Parse for Weight {
     // CSS has one deviation from this spec, which uses the value "950" for extra_black.
     // skia_safe also has an "invisible" weight smaller than the thin weight, which could fall under CSS's interpretation of OpenType's
     // version. In this case it would be font_weight: "50".
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "invisible" => Weight::INVISIBLE,
-            "thin" => Weight::THIN,
-            "extra-light" => Weight::EXTRA_LIGHT,
-            "light" => Weight::LIGHT,
-            "normal" => Weight::NORMAL,
-            "medium" => Weight::MEDIUM,
-            "semi-bold" => Weight::SEMI_BOLD,
-            "bold" => Weight::BOLD,
-            "extra-bold" => Weight::EXTRA_BOLD,
-            "black" => Weight::BLACK,
-            "extra-black" => Weight::EXTRA_BLACK,
-            "50" => Weight::INVISIBLE,
-            "100" => Weight::THIN,
-            "200" => Weight::EXTRA_LIGHT,
-            "300" => Weight::LIGHT,
-            "400" => Weight::NORMAL,
-            "500" => Weight::MEDIUM,
-            "600" => Weight::SEMI_BOLD,
-            "700" => Weight::BOLD,
-            "800" => Weight::EXTRA_BOLD,
-            "900" => Weight::BLACK,
-            "950" => Weight::EXTRA_BLACK,
-            _ => Weight::NORMAL,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|token| {
+            if token.is_i64() {
+                token.try_as_i64().and_then(|value| match value {
+                    50 => Some(Weight::INVISIBLE),
+                    100 => Some(Weight::THIN),
+                    200 => Some(Weight::EXTRA_LIGHT),
+                    300 => Some(Weight::LIGHT),
+                    400 => Some(Weight::NORMAL),
+                    500 => Some(Weight::MEDIUM),
+                    600 => Some(Weight::SEMI_BOLD),
+                    700 => Some(Weight::BOLD),
+                    800 => Some(Weight::EXTRA_BOLD),
+                    900 => Some(Weight::BLACK),
+                    950 => Some(Weight::EXTRA_BLACK),
+                    _ => None,
+                })
+            } else {
+                token.try_as_str().and_then(|value| match value {
+                    "invisible" => Some(Weight::INVISIBLE),
+                    "thin" => Some(Weight::THIN),
+                    "extra-light" => Some(Weight::EXTRA_LIGHT),
+                    "light" => Some(Weight::LIGHT),
+                    "normal" => Some(Weight::NORMAL),
+                    "medium" => Some(Weight::MEDIUM),
+                    "semi-bold" => Some(Weight::SEMI_BOLD),
+                    "bold" => Some(Weight::BOLD),
+                    "extra-bold" => Some(Weight::EXTRA_BOLD),
+                    "black" => Some(Weight::BLACK),
+                    "extra-black" => Some(Weight::EXTRA_BLACK),
+                    _ => None,
+                })
+            }
         })
     }
 }
@@ -109,6 +124,10 @@ impl TextOverflow {
 }
 
 impl Parse for TextOverflow {
+    fn from_parser(_: &mut Parser) -> Result<Self, ParseError> {
+        unimplemented!()
+    }
+
     fn parse(value: &str) -> Result<Self, ParseError> {
         Ok(match value {
             "ellipsis" => TextOverflow::Ellipsis,
diff --git a/crates/state/src/values/gaps.rs b/crates/state/src/values/gaps.rs
index 70a61be21..ef2884af0 100644
--- a/crates/state/src/values/gaps.rs
+++ b/crates/state/src/values/gaps.rs
@@ -3,92 +3,43 @@ use torin::gaps::Gaps;
 use crate::{
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 impl Parse for Gaps {
-    fn parse(value: &str) -> Result<Self, ParseError> {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
         let mut paddings = Gaps::default();
 
-        if value == "none" {
+        if parser.try_consume(&Token::ident("none")) {
             return Ok(paddings);
         }
 
-        let mut values = value.split_ascii_whitespace();
-
-        match values.clone().count() {
+        match (
+            parser.consume_map(Token::try_as_f32)?,
+            parser.consume_map(Token::try_as_f32).ok(),
+            parser.consume_map(Token::try_as_f32).ok(),
+            parser.consume_map(Token::try_as_f32).ok(),
+        ) {
             // Same in each directions
-            1 => {
-                paddings.fill_all(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                );
+            (value, None, None, None) => {
+                paddings.fill_all(value);
             }
             // By vertical and horizontal
-            2 => {
+            (vertical, Some(horizontal), None, None) => {
                 // Vertical
-                paddings.fill_vertical(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                );
+                paddings.fill_vertical(vertical);
 
                 // Horizontal
-                paddings.fill_horizontal(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                )
+                paddings.fill_horizontal(horizontal);
             }
             // Individual vertical but same horizontal
-            3 => {
-                let top = values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-                let left_and_right = values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
-                let bottom = values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?;
+            (top, Some(left_and_right), Some(bottom), None) => {
                 paddings = Gaps::new(top, left_and_right, bottom, left_and_right);
             }
             // Each directions
-            4 => {
-                paddings = Gaps::new(
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                    values
-                        .next()
-                        .ok_or(ParseError)?
-                        .parse::<f32>()
-                        .map_err(|_| ParseError)?,
-                );
+            (top, Some(right), Some(bottom), Some(left)) => {
+                paddings = Gaps::new(top, right, bottom, left);
             }
             _ => {}
         }
diff --git a/crates/state/src/values/gradient.rs b/crates/state/src/values/gradient.rs
index b3202ae43..0e36628f3 100644
--- a/crates/state/src/values/gradient.rs
+++ b/crates/state/src/values/gradient.rs
@@ -10,10 +10,13 @@ use torin::{
 };
 
 use crate::{
+    parse_angle,
+    parse_func,
     DisplayColor,
-    ExtSplit,
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -23,25 +26,13 @@ pub struct GradientStop {
 }
 
 impl Parse for GradientStop {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        let mut split = value.split_ascii_whitespace_excluding_group('(', ')');
-        let color_str = split.next().ok_or(ParseError)?;
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        let color = Color::from_parser(parser)?;
+        let offset = (parser.consume_map(Token::try_as_f32)? / 100.0).clamp(0.0, 1.0);
 
-        let offset_str = split.next().ok_or(ParseError)?.trim();
-        if !offset_str.ends_with('%') || split.next().is_some() {
-            return Err(ParseError);
-        }
-
-        let offset = offset_str
-            .replacen('%', "", 1)
-            .parse::<f32>()
-            .map_err(|_| ParseError)?
-            / 100.0;
+        parser.consume(&Token::Percent)?;
 
-        Ok(GradientStop {
-            color: Color::parse(color_str).map_err(|_| ParseError)?,
-            offset,
-        })
+        Ok(GradientStop { color, offset })
     }
 }
 
@@ -88,34 +79,20 @@ impl LinearGradient {
 }
 
 impl Parse for LinearGradient {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        if !value.starts_with("linear-gradient(") || !value.ends_with(')') {
-            return Err(ParseError);
-        }
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parse_func(parser, "linear-gradient", |parser| {
+            let mut gradient = Self::default();
 
-        let mut gradient = LinearGradient::default();
-        let mut value = value.replacen("linear-gradient(", "", 1);
-        value.remove(value.rfind(')').ok_or(ParseError)?);
+            if let Ok(angle) = parse_angle(parser) {
+                parser.consume(&Token::Comma)?;
 
-        let mut split = value.split_excluding_group(',', '(', ')');
-
-        let angle_or_first_stop = split.next().ok_or(ParseError)?.trim();
-
-        if angle_or_first_stop.ends_with("deg") {
-            if let Ok(angle) = angle_or_first_stop.replacen("deg", "", 1).parse::<f32>() {
                 gradient.angle = angle;
             }
-        } else {
-            gradient
-                .stops
-                .push(GradientStop::parse(angle_or_first_stop)?);
-        }
 
-        for stop in split {
-            gradient.stops.push(GradientStop::parse(stop)?);
-        }
+            gradient.stops = GradientStop::from_parser_multiple(parser, &Token::Comma)?;
 
-        Ok(gradient)
+            Ok(gradient)
+        })
     }
 }
 
@@ -159,21 +136,10 @@ impl RadialGradient {
 }
 
 impl Parse for RadialGradient {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        if !value.starts_with("radial-gradient(") || !value.ends_with(')') {
-            return Err(ParseError);
-        }
-
-        let mut gradient = RadialGradient::default();
-        let mut value = value.replacen("radial-gradient(", "", 1);
-
-        value.remove(value.rfind(')').ok_or(ParseError)?);
-
-        for stop in value.split_excluding_group(',', '(', ')') {
-            gradient.stops.push(GradientStop::parse(stop)?);
-        }
-
-        Ok(gradient)
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parse_func(parser, "radial-gradient", |parser| {
+            GradientStop::from_parser_multiple(parser, &Token::Comma).map(|stops| Self { stops })
+        })
     }
 }
 
@@ -221,59 +187,34 @@ impl ConicGradient {
 }
 
 impl Parse for ConicGradient {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        if !value.starts_with("conic-gradient(") || !value.ends_with(')') {
-            return Err(ParseError);
-        }
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parse_func(parser, "conic-gradient", |parser| {
+            let mut gradient = Self::default();
 
-        let mut gradient = ConicGradient::default();
-        let mut value = value.replacen("conic-gradient(", "", 1);
+            if let Ok(angle) = parse_angle(parser) {
+                gradient.angle = Some(angle);
 
-        value.remove(value.rfind(')').ok_or(ParseError)?);
+                parser.consume(&Token::Comma)?;
+            }
 
-        let mut split = value.split_excluding_group(',', '(', ')');
+            if parser.try_consume(&Token::ident("from")) {
+                let start = parse_angle(parser)?;
 
-        let angle_or_first_stop = split.next().ok_or(ParseError)?.trim();
+                let end = if parser.try_consume(&Token::ident("to")) {
+                    parse_angle(parser)?
+                } else {
+                    360.0
+                };
 
-        if angle_or_first_stop.ends_with("deg") {
-            if let Ok(angle) = angle_or_first_stop.replacen("deg", "", 1).parse::<f32>() {
-                gradient.angle = Some(angle);
-            }
-        } else {
-            gradient
-                .stops
-                .push(GradientStop::parse(angle_or_first_stop).map_err(|_| ParseError)?);
-        }
+                gradient.angles = Some((start, end));
 
-        if let Some(angles_or_second_stop) = split.next().map(str::trim) {
-            if angles_or_second_stop.starts_with("from ") && angles_or_second_stop.ends_with("deg")
-            {
-                if let Some(start) = angles_or_second_stop
-                    .find("deg")
-                    .and_then(|index| angles_or_second_stop.get(5..index))
-                    .and_then(|slice| slice.parse::<f32>().ok())
-                {
-                    let end = angles_or_second_stop
-                        .find(" to ")
-                        .and_then(|index| angles_or_second_stop.get(index + 4..))
-                        .and_then(|slice| slice.find("deg").and_then(|index| slice.get(0..index)))
-                        .and_then(|slice| slice.parse::<f32>().ok())
-                        .unwrap_or(360.0);
-
-                    gradient.angles = Some((start, end));
-                }
-            } else {
-                gradient
-                    .stops
-                    .push(GradientStop::parse(angles_or_second_stop)?);
+                parser.consume(&Token::Comma)?;
             }
-        }
 
-        for stop in split {
-            gradient.stops.push(GradientStop::parse(stop)?);
-        }
+            gradient.stops = GradientStop::from_parser_multiple(parser, &Token::Comma)?;
 
-        Ok(gradient)
+            Ok(gradient)
+        })
     }
 }
 
diff --git a/crates/state/src/values/highlight.rs b/crates/state/src/values/highlight.rs
index 4f1b96542..38e289a86 100644
--- a/crates/state/src/values/highlight.rs
+++ b/crates/state/src/values/highlight.rs
@@ -1,6 +1,7 @@
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 #[derive(Default, Clone, Debug, PartialEq)]
@@ -13,10 +14,13 @@ pub enum HighlightMode {
 }
 
 impl Parse for HighlightMode {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        match value {
-            "expanded" => Ok(HighlightMode::Expanded),
-            _ => Ok(HighlightMode::Fit),
-        }
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "expanded" => Some(Self::Expanded),
+                "fit" => Some(Self::Fit),
+                _ => None,
+            })
+        })
     }
 }
diff --git a/crates/state/src/values/overflow.rs b/crates/state/src/values/overflow.rs
index e5a87f051..c241a621b 100644
--- a/crates/state/src/values/overflow.rs
+++ b/crates/state/src/values/overflow.rs
@@ -3,6 +3,7 @@ use std::fmt;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 #[derive(Clone, Debug, PartialEq, Eq, Default)]
@@ -13,10 +14,13 @@ pub enum OverflowMode {
 }
 
 impl Parse for OverflowMode {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "clip" => OverflowMode::Clip,
-            _ => OverflowMode::None,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "clip" => Some(Self::Clip),
+                "none" => Some(Self::None),
+                _ => None,
+            })
         })
     }
 }
@@ -24,8 +28,8 @@ impl Parse for OverflowMode {
 impl fmt::Display for OverflowMode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match self {
-            OverflowMode::Clip => "clip",
-            OverflowMode::None => "none",
+            Self::Clip => "clip",
+            Self::None => "none",
         })
     }
 }
diff --git a/crates/state/src/values/position.rs b/crates/state/src/values/position.rs
index 2d73ed5dd..236e7ed95 100644
--- a/crates/state/src/values/position.rs
+++ b/crates/state/src/values/position.rs
@@ -3,13 +3,17 @@ use torin::position::Position;
 use crate::{
     Parse,
     ParseError,
+    Parser,
 };
 
 impl Parse for Position {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        Ok(match value {
-            "absolute" => Position::new_absolute(),
-            _ => Position::Stacked,
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "absolute" => Some(Self::new_absolute()),
+                "stacked" => Some(Self::Stacked),
+                _ => None,
+            })
         })
     }
 }
diff --git a/crates/state/src/values/shadow.rs b/crates/state/src/values/shadow.rs
index 907feb5df..adda40d53 100644
--- a/crates/state/src/values/shadow.rs
+++ b/crates/state/src/values/shadow.rs
@@ -1,10 +1,11 @@
 use torin::scaled::Scaled;
 
 use crate::{
-    ExtSplit,
     Fill,
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 #[derive(Default, Clone, Debug, PartialEq)]
@@ -25,51 +26,26 @@ pub struct Shadow {
 }
 
 impl Parse for Shadow {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        let mut shadow_values = value.split_ascii_whitespace_excluding_group('(', ')');
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
         let mut shadow = Shadow::default();
 
-        let first = shadow_values.next().ok_or(ParseError)?;
+        if parser.try_consume(&Token::ident("none")) {
+            return Ok(shadow);
+        }
 
-        if first == "inset" {
+        if parser.try_consume(&Token::ident("inset")) {
             shadow.position = ShadowPosition::Inset;
-            shadow.x = shadow_values
-                .next()
-                .ok_or(ParseError)?
-                .parse::<f32>()
-                .map_err(|_| ParseError)?;
-        } else {
-            shadow.x = first.parse::<f32>().map_err(|_| ParseError)?;
         }
 
-        shadow.y = shadow_values
-            .next()
-            .ok_or(ParseError)?
-            .parse::<f32>()
-            .map_err(|_| ParseError)?;
-        shadow.blur = shadow_values
-            .next()
-            .ok_or(ParseError)?
-            .parse::<f32>()
-            .map_err(|_| ParseError)?;
-
-        let spread_or_fill = shadow_values.next().ok_or(ParseError)?;
+        shadow.x = parser.consume_map(Token::try_as_f32)?;
+        shadow.y = parser.consume_map(Token::try_as_f32)?;
+        shadow.blur = parser.consume_map(Token::try_as_f32)?;
 
-        let mut already_filled = false;
-        if let Ok(spread) = spread_or_fill.parse::<f32>() {
+        if let Ok(spread) = parser.consume_map(Token::try_as_f32) {
             shadow.spread = spread;
-        } else {
-            already_filled = true;
-            shadow.fill = Fill::parse(spread_or_fill).map_err(|_| ParseError)?;
         }
 
-        if let Some(fill) = shadow_values.next() {
-            if !already_filled {
-                shadow.fill = Fill::parse(fill).map_err(|_| ParseError)?
-            } else {
-                return Err(ParseError);
-            }
-        }
+        shadow.fill = Fill::from_parser(parser)?;
 
         Ok(shadow)
     }
diff --git a/crates/state/src/values/size.rs b/crates/state/src/values/size.rs
index ae856e511..6c593844a 100644
--- a/crates/state/src/values/size.rs
+++ b/crates/state/src/values/size.rs
@@ -7,83 +7,73 @@ use torin::{
 };
 
 use crate::{
+    parse_func,
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 impl Parse for Size {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        if value == "auto" {
-            Ok(Size::Inner)
-        } else if value == "fill" {
-            Ok(Size::Fill)
-        } else if value == "fill-min" {
-            Ok(Size::FillMinimum)
-        } else if value.contains("calc") {
-            Ok(Size::DynamicCalculations(Box::new(parse_calc(value)?)))
-        } else if value.contains('%') {
-            Ok(Size::Percentage(Length::new(
-                value
-                    .replace('%', "")
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?,
-            )))
-        } else if value.contains('v') {
-            Ok(Size::RootPercentage(Length::new(
-                value
-                    .replace('v', "")
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?,
-            )))
-        } else if value.contains('a') {
-            Ok(Size::InnerPercentage(Length::new(
-                value
-                    .replace('a', "")
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?,
-            )))
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        if parser.check(&Token::ident("calc")) {
+            parse_calc(parser).map(|value| Self::DynamicCalculations(Box::new(value)))
+        } else if let Ok(value) = parser.consume_if(Token::is_ident).map(Token::into_string) {
+            match value.as_str() {
+                "auto" => Ok(Self::Inner),
+                "fill" => Ok(Self::Fill),
+                "fill-min" => Ok(Self::FillMinimum),
+                value => Err(ParseError::invalid_ident(
+                    value,
+                    &["auto", "fill", "fill-min"],
+                )),
+            }
         } else {
-            Ok(Size::Pixels(Length::new(
-                value.parse::<f32>().map_err(|_| ParseError)?,
-            )))
+            let value = parser.consume_map(Token::try_as_f32)?;
+
+            Ok(if parser.try_consume(&Token::Percent) {
+                Size::Percentage(Length::new(value))
+            } else if parser.try_consume(&Token::ident("v")) {
+                Size::RootPercentage(Length::new(value))
+            } else if parser.try_consume(&Token::ident("a")) {
+                Size::InnerPercentage(Length::new(value))
+            } else {
+                Size::Pixels(Length::new(value))
+            })
         }
     }
 }
 
-pub fn parse_calc(mut value: &str) -> Result<Vec<DynamicCalculation>, ParseError> {
-    let mut calcs = Vec::new();
-
-    value = value
-        .strip_prefix("calc(")
-        .ok_or(ParseError)?
-        .strip_suffix(')')
-        .ok_or(ParseError)?;
-
-    let values = value.split_whitespace();
-
-    for val in values {
-        if val.contains('%') {
-            calcs.push(DynamicCalculation::Percentage(
-                val.replace('%', "").parse().map_err(|_| ParseError)?,
-            ));
-        } else if val.contains('v') {
-            calcs.push(DynamicCalculation::RootPercentage(
-                val.replace('v', "").parse().map_err(|_| ParseError)?,
-            ));
-        } else if val == "+" {
-            calcs.push(DynamicCalculation::Add);
-        } else if val == "-" {
-            calcs.push(DynamicCalculation::Sub);
-        } else if val == "/" {
-            calcs.push(DynamicCalculation::Div);
-        } else if val == "*" {
-            calcs.push(DynamicCalculation::Mul);
+impl Parse for DynamicCalculation {
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(value) = parser.consume_map(Token::try_as_f32) {
+            Ok(if parser.try_consume(&Token::Percent) {
+                DynamicCalculation::Percentage(value)
+            } else if parser.try_consume(&Token::ident("v")) {
+                DynamicCalculation::RootPercentage(value)
+            } else {
+                DynamicCalculation::Pixels(value)
+            })
         } else {
-            calcs.push(DynamicCalculation::Pixels(
-                val.parse::<f32>().map_err(|_| ParseError)?,
-            ));
+            parser.consume_map(|token| match token {
+                Token::Plus => Some(Self::Add),
+                Token::Minus => Some(Self::Sub),
+                Token::Slash => Some(Self::Div),
+                Token::Star => Some(Self::Mul),
+                _ => None,
+            })
         }
     }
+}
+
+pub fn parse_calc(parser: &mut Parser) -> Result<Vec<DynamicCalculation>, ParseError> {
+    parse_func(parser, "calc", |parser| {
+        let mut calcs = Vec::new();
+
+        while let Ok(value) = DynamicCalculation::from_parser(parser) {
+            calcs.push(value);
+        }
 
-    Ok(calcs)
+        Ok(calcs)
+    })
 }
diff --git a/crates/state/src/values/text_height.rs b/crates/state/src/values/text_height.rs
index 4977b383d..cb0f25033 100644
--- a/crates/state/src/values/text_height.rs
+++ b/crates/state/src/values/text_height.rs
@@ -6,14 +6,16 @@ use crate::{
 };
 
 impl Parse for TextHeightBehavior {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        match value {
-            "all" => Ok(TextHeightBehavior::All),
-            "disable-first-ascent" => Ok(TextHeightBehavior::DisableFirstAscent),
-            "disable-least-ascent" => Ok(TextHeightBehavior::DisableLastDescent),
-            "disable-all" => Ok(TextHeightBehavior::DisableAll),
-            _ => Err(ParseError),
-        }
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        parser.consume_map(|value| {
+            value.try_as_str().and_then(|value| match value {
+                "all" => Some(TextHeightBehavior::All),
+                "disable-first-ascent" => Some(TextHeightBehavior::DisableFirstAscent),
+                "disable-least-ascent" => Some(TextHeightBehavior::DisableLastDescent),
+                "disable-all" => Some(TextHeightBehavior::DisableAll),
+                _ => None,
+            })
+        })
     }
 }
 
diff --git a/crates/state/src/values/text_shadow.rs b/crates/state/src/values/text_shadow.rs
index 102e25ed3..a17e3f0dd 100644
--- a/crates/state/src/values/text_shadow.rs
+++ b/crates/state/src/values/text_shadow.rs
@@ -3,34 +3,27 @@ use freya_engine::prelude::*;
 use crate::{
     Parse,
     ParseError,
+    Parser,
+    Token,
 };
 
 // Same as shadow, but no inset or spread.
 impl Parse for TextShadow {
-    fn parse(value: &str) -> Result<Self, ParseError> {
-        let mut shadow_values = value.split_ascii_whitespace();
-        Ok(TextShadow {
-            offset: (
-                shadow_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?,
-                shadow_values
-                    .next()
-                    .ok_or(ParseError)?
-                    .parse::<f32>()
-                    .map_err(|_| ParseError)?,
-            )
-                .into(),
-            blur_sigma: shadow_values
-                .next()
-                .ok_or(ParseError)?
-                .parse::<f64>()
-                .map_err(|_| ParseError)?
-                / 2.0,
-            color: Color::parse(shadow_values.collect::<Vec<&str>>().join(" ").as_str())
-                .map_err(|_| ParseError)?,
-        })
+    fn from_parser(parser: &mut Parser) -> Result<Self, ParseError> {
+        let shadow = if parser.try_consume(&Token::ident("none")) {
+            Self::default()
+        } else {
+            TextShadow {
+                offset: (
+                    parser.consume_map(Token::try_as_f32)?,
+                    parser.consume_map(Token::try_as_f32)?,
+                )
+                    .into(),
+                blur_sigma: parser.consume_map(Token::try_as_f32)? as f64 / 2.0,
+                color: Color::from_parser(parser)?,
+            }
+        };
+
+        Ok(shadow)
     }
 }
diff --git a/crates/state/src/viewport.rs b/crates/state/src/viewport.rs
index 4255d4420..8a06cd05e 100644
--- a/crates/state/src/viewport.rs
+++ b/crates/state/src/viewport.rs
@@ -32,12 +32,12 @@ impl ParseAttribute for ViewportState {
     fn parse_attribute(
         &mut self,
         attr: freya_native_core::prelude::OwnedAttributeView<CustomAttributeValues>,
-    ) -> Result<(), crate::ParseError> {
+    ) -> Result<(), ParseError> {
         #[allow(clippy::single_match)]
         match attr.attribute {
             AttributeName::Overflow => {
                 if let Some(value) = attr.value.as_text() {
-                    self.overflow = OverflowMode::parse(value).map_err(|_| ParseError)?;
+                    self.overflow = OverflowMode::parse(value)?;
                 }
             }
             _ => {}
diff --git a/crates/state/tests/parse_border.rs b/crates/state/tests/parse_border.rs
index 6126106f6..de3eea1bc 100644
--- a/crates/state/tests/parse_border.rs
+++ b/crates/state/tests/parse_border.rs
@@ -132,5 +132,5 @@ fn parse_border_alignments() {
     assert_eq!(inner, Ok(BorderAlignment::Inner));
     assert_eq!(outer, Ok(BorderAlignment::Outer));
     assert_eq!(center, Ok(BorderAlignment::Center));
-    assert_eq!(invalid, Ok(BorderAlignment::Inner));
+    assert!(invalid.is_err());
 }
diff --git a/crates/state/tests/parse_decoration.rs b/crates/state/tests/parse_decoration.rs
index 0d3e9ed77..62230ddd2 100644
--- a/crates/state/tests/parse_decoration.rs
+++ b/crates/state/tests/parse_decoration.rs
@@ -12,8 +12,9 @@ fn parse_text_decoration() {
     let line_through = TextDecoration::parse("line-through");
     assert_eq!(line_through, Ok(TextDecoration::LINE_THROUGH));
 
-    let fallback = TextDecoration::parse("Rust");
-    assert_eq!(fallback, Ok(TextDecoration::NO_DECORATION));
+    let invalid_decoration_name = TextDecoration::parse("Rust");
+
+    assert!(invalid_decoration_name.is_err());
 }
 
 #[test]
@@ -33,6 +34,7 @@ fn parse_text_decoration_style() {
     let wavy = TextDecorationStyle::parse("wavy");
     assert_eq!(wavy, Ok(TextDecorationStyle::Wavy));
 
-    let fallback = TextDecorationStyle::parse("Rust");
-    assert_eq!(fallback, Ok(TextDecorationStyle::Solid));
+    let invalid_decoration_style = TextDecorationStyle::parse("Rust");
+
+    assert!(invalid_decoration_style.is_err());
 }
diff --git a/crates/state/tests/parse_display.rs b/crates/state/tests/parse_display.rs
index 9cd74e4c7..4af555913 100644
--- a/crates/state/tests/parse_display.rs
+++ b/crates/state/tests/parse_display.rs
@@ -40,5 +40,6 @@ fn parse_space_evenly_alignment() {
 #[test]
 fn parse_fallback_alignment() {
     let alignment = Alignment::parse("Hello, World!");
-    assert_eq!(alignment, Ok(Alignment::Start));
+
+    assert!(alignment.is_err());
 }
diff --git a/crates/state/tests/parse_focusable.rs b/crates/state/tests/parse_focusable.rs
index 62ae1d9c9..27832e9a7 100644
--- a/crates/state/tests/parse_focusable.rs
+++ b/crates/state/tests/parse_focusable.rs
@@ -1,4 +1,3 @@
-use freya_engine::prelude::*;
 use freya_node_state::{
     Focusable,
     Parse,
diff --git a/crates/state/tests/parse_highlight.rs b/crates/state/tests/parse_highlight.rs
index 913ab3b67..dc3af1daa 100644
--- a/crates/state/tests/parse_highlight.rs
+++ b/crates/state/tests/parse_highlight.rs
@@ -18,5 +18,6 @@ fn parse_fit_highlight_mode() {
 #[test]
 fn parse_fallback_highlight_mode() {
     let fallback = HighlightMode::parse("Hello, World!");
-    assert_eq!(fallback, Ok(HighlightMode::Fit));
+
+    assert!(fallback.is_err());
 }