diff --git a/crates/encoding/src/encoding.rs b/crates/encoding/src/encoding.rs
index 997fada65..1eb524dfb 100644
--- a/crates/encoding/src/encoding.rs
+++ b/crates/encoding/src/encoding.rs
@@ -1,7 +1,7 @@
 // Copyright 2022 The Vello authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use super::{DrawColor, DrawTag, PathEncoder, PathTag, Transform};
+use super::{DrawColor, DrawTag, PathEncoder, PathTag, Style, Transform};
 
 use peniko::{kurbo::Shape, BlendMode, BrushRef, Color, Fill};
 
@@ -25,8 +25,8 @@ pub struct Encoding {
     pub draw_data: Vec<u8>,
     /// The transform stream.
     pub transforms: Vec<Transform>,
-    /// The line width stream.
-    pub linewidths: Vec<f32>,
+    /// The style stream
+    pub styles: Vec<Style>,
     /// Late bound resource data.
     #[cfg(feature = "full")]
     pub resources: Resources,
@@ -56,7 +56,7 @@ impl Encoding {
         self.transforms.clear();
         self.path_tags.clear();
         self.path_data.clear();
-        self.linewidths.clear();
+        self.styles.clear();
         self.draw_data.clear();
         self.draw_tags.clear();
         self.n_paths = 0;
@@ -67,7 +67,7 @@ impl Encoding {
         self.resources.reset();
         if !is_fragment {
             self.transforms.push(Transform::IDENTITY);
-            self.linewidths.push(-1.0);
+            self.styles.push(Style::from_fill(Fill::NonZero));
         }
     }
 
@@ -96,7 +96,7 @@ impl Encoding {
                     run.stream_offsets.draw_tags += offsets.draw_tags;
                     run.stream_offsets.draw_data += offsets.draw_data;
                     run.stream_offsets.transforms += offsets.transforms;
-                    run.stream_offsets.linewidths += offsets.linewidths;
+                    run.stream_offsets.styles += offsets.styles;
                     run
                 }));
             self.resources
@@ -148,7 +148,7 @@ impl Encoding {
         } else {
             self.transforms.extend_from_slice(&other.transforms);
         }
-        self.linewidths.extend_from_slice(&other.linewidths);
+        self.styles.extend_from_slice(&other.styles);
     }
 
     /// Returns a snapshot of the current stream offsets.
@@ -159,19 +159,16 @@ impl Encoding {
             draw_tags: self.draw_tags.len(),
             draw_data: self.draw_data.len(),
             transforms: self.transforms.len(),
-            linewidths: self.linewidths.len(),
+            styles: self.styles.len(),
         }
     }
 
     /// Encodes a fill style.
     pub fn encode_fill_style(&mut self, fill: Fill) {
-        let linewidth = match fill {
-            Fill::NonZero => -1.0,
-            Fill::EvenOdd => -2.0,
-        };
-        if self.linewidths.last() != Some(&linewidth) {
-            self.path_tags.push(PathTag::LINEWIDTH);
-            self.linewidths.push(linewidth);
+        let style = Style::from_fill(fill);
+        if self.styles.last() != Some(&style) {
+            self.path_tags.push(PathTag::STYLE);
+            self.styles.push(style);
         }
     }
 
@@ -449,8 +446,8 @@ pub struct StreamOffsets {
     pub draw_data: usize,
     /// Current length of transform stream.
     pub transforms: usize,
-    /// Current length of linewidth stream.
-    pub linewidths: usize,
+    /// Current length of style stream.
+    pub styles: usize,
 }
 
 impl StreamOffsets {
@@ -461,6 +458,6 @@ impl StreamOffsets {
         self.draw_tags += other.draw_tags;
         self.draw_data += other.draw_data;
         self.transforms += other.transforms;
-        self.linewidths += other.linewidths;
+        self.styles += other.styles;
     }
 }
diff --git a/crates/encoding/src/glyph_cache.rs b/crates/encoding/src/glyph_cache.rs
index 3469c13b7..6ed8bb319 100644
--- a/crates/encoding/src/glyph_cache.rs
+++ b/crates/encoding/src/glyph_cache.rs
@@ -105,7 +105,7 @@ impl CachedRange {
             draw_tags: self.end.draw_tags - self.start.draw_tags,
             draw_data: self.end.draw_data - self.start.draw_data,
             transforms: self.end.transforms - self.start.transforms,
-            linewidths: self.end.linewidths - self.start.linewidths,
+            styles: self.end.styles - self.start.styles,
         }
     }
 }
diff --git a/crates/encoding/src/lib.rs b/crates/encoding/src/lib.rs
index 3d24c192f..798bf9890 100644
--- a/crates/encoding/src/lib.rs
+++ b/crates/encoding/src/lib.rs
@@ -36,7 +36,7 @@ pub use math::Transform;
 pub use monoid::Monoid;
 pub use path::{
     Cubic, LineSoup, Path, PathBbox, PathEncoder, PathMonoid, PathSegment, PathSegmentType,
-    PathTag, SegmentCount, Tile,
+    PathTag, SegmentCount, Style, Tile,
 };
 pub use resolve::{resolve_solid_paths_only, Layout};
 
diff --git a/crates/encoding/src/math.rs b/crates/encoding/src/math.rs
index 5873fba9a..822f43424 100644
--- a/crates/encoding/src/math.rs
+++ b/crates/encoding/src/math.rs
@@ -76,3 +76,100 @@ impl Mul for Transform {
 pub fn point_to_f32(point: kurbo::Point) -> [f32; 2] {
     [point.x as f32, point.y as f32]
 }
+
+/// Converts an f32 to IEEE-754 binary16 format represented as the bits of a u16.
+/// This implementation was adapted from Fabian Giesen's float_to_half_fast3()
+/// function which can be found at https://gist.github.com/rygorous/2156668#file-gistfile1-cpp-L285
+///
+/// TODO: We should consider adopting https://crates.io/crates/half as a dependency since it nicely
+/// wraps native ARM and x86 instructions for floating-point conversion.
+#[allow(unused)] // for now
+pub(crate) fn f32_to_f16(val: f32) -> u16 {
+    const INF_32: u32 = 255 << 23;
+    const INF_16: u32 = 31 << 23;
+    const MAGIC: u32 = 15 << 23;
+    const SIGN_MASK: u32 = 0x8000_0000u32;
+    const ROUND_MASK: u32 = !0xFFFu32;
+
+    let u = val.to_bits();
+    let sign = u & SIGN_MASK;
+    let u = u ^ sign;
+
+    // NOTE all the integer compares in this function can be safely
+    // compiled into signed compares since all operands are below
+    // 0x80000000. Important if you want fast straight SSE2 code
+    // (since there's no unsigned PCMPGTD).
+
+    // Inf or NaN (all exponent bits set)
+    let output: u16 = if u >= INF_32 {
+        // NaN -> qNaN and Inf->Inf
+        if u > INF_32 {
+            0x7E00
+        } else {
+            0x7C00
+        }
+    } else {
+        // (De)normalized number or zero
+        let mut u = u & ROUND_MASK;
+        u = (f32::from_bits(u) * f32::from_bits(MAGIC)).to_bits();
+        u = u.overflowing_sub(ROUND_MASK).0;
+
+        // Clamp to signed infinity if exponent overflowed
+        if u > INF_16 {
+            u = INF_16;
+        }
+        (u >> 13) as u16 // Take the bits!
+    };
+    output | (sign >> 16) as u16
+}
+
+#[cfg(test)]
+mod tests {
+    use super::f32_to_f16;
+
+    #[test]
+    fn test_f32_to_f16_simple() {
+        let input: f32 = std::f32::consts::PI;
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0x4248u16, output) // 3.141
+    }
+
+    #[test]
+    fn test_f32_to_f16_nan_overflow() {
+        // A signaling NaN with unset high bits but a low bit that could get accidentally masked
+        // should get converted to a quiet NaN and not infinity.
+        let input: f32 = f32::from_bits(0x7F800001u32);
+        assert!(input.is_nan());
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0x7E00, output);
+    }
+
+    #[test]
+    fn test_f32_to_16_inf() {
+        let input: f32 = f32::from_bits(0x7F800000u32);
+        assert!(input.is_infinite());
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0x7C00, output);
+    }
+
+    #[test]
+    fn test_f32_to_16_exponent_rebias() {
+        let input: f32 = 0.00003051758;
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0x0200, output); // 0.00003052
+    }
+
+    #[test]
+    fn test_f32_to_16_exponent_overflow() {
+        let input: f32 = 1.701412e38;
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0x7C00, output); // +inf
+    }
+
+    #[test]
+    fn test_f32_to_16_exponent_overflow_neg_inf() {
+        let input: f32 = -1.701412e38;
+        let output: u16 = f32_to_f16(input);
+        assert_eq!(0xFC00, output); // -inf
+    }
+}
diff --git a/crates/encoding/src/path.rs b/crates/encoding/src/path.rs
index b0a52b0b7..f586f8773 100644
--- a/crates/encoding/src/path.rs
+++ b/crates/encoding/src/path.rs
@@ -2,10 +2,185 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
 use bytemuck::{Pod, Zeroable};
-use peniko::kurbo::Shape;
+use peniko::{
+    kurbo::{Cap, Join, Shape, Stroke},
+    Fill,
+};
 
 use super::Monoid;
 
+/// Data structure encoding stroke or fill style.
+#[derive(Clone, Copy, Debug, Zeroable, Pod, Default, PartialEq)]
+#[repr(C)]
+pub struct Style {
+    /// Encodes the stroke and fill style parameters. This field is split into two 16-bit
+    /// parts:
+    ///
+    /// - flags: u16 - encodes fill vs stroke, even-odd vs non-zero fill mode for fills and cap
+    ///                and join style for strokes. See the FLAGS_* constants below for more
+    ///                information.
+    /// ```text
+    /// flags: |style|fill|join|start cap|end cap|reserved|
+    ///  bits:  0     1    2-3  4-5       6-7     8-15
+    /// ```
+    ///
+    /// - miter_limit: u16 - The miter limit for a stroke, encoded in binary16 (half) floating
+    ///                      point representation. This field is only meaningful for the
+    ///                      `Join::Miter` join style. It's ignored for other stroke styles and
+    ///                      fills.
+    pub flags_and_miter_limit: u32,
+
+    /// Encodes the stroke width. This field is ignored for fills.
+    pub line_width: f32,
+}
+
+impl Style {
+    /// 0 for a fill, 1 for a stroke
+    pub const FLAGS_STYLE_BIT: u32 = 0x8000_0000;
+
+    /// 0 for non-zero, 1 for even-odd
+    pub const FLAGS_FILL_BIT: u32 = 0x4000_0000;
+
+    /// Encodings for join style:
+    ///    - 0b00 -> bevel
+    ///    - 0b01 -> miter
+    ///    - 0b10 -> round
+    pub const FLAGS_JOIN_BITS_BEVEL: u32 = 0;
+    pub const FLAGS_JOIN_BITS_MITER: u32 = 0x1000_0000;
+    pub const FLAGS_JOIN_BITS_ROUND: u32 = 0x2000_0000;
+
+    #[cfg(test)]
+    pub const FLAGS_JOIN_MASK: u32 = 0x3000_0000;
+
+    /// Encodings for cap style:
+    ///    - 0b00 -> butt
+    ///    - 0b01 -> square
+    ///    - 0b10 -> round
+    pub const FLAGS_START_CAP_BITS_BUTT: u32 = 0;
+    pub const FLAGS_START_CAP_BITS_SQUARE: u32 = 0x0400_0000;
+    pub const FLAGS_START_CAP_BITS_ROUND: u32 = 0x0800_0000;
+    pub const FLAGS_END_CAP_BITS_BUTT: u32 = 0;
+    pub const FLAGS_END_CAP_BITS_SQUARE: u32 = 0x0100_0000;
+    pub const FLAGS_END_CAP_BITS_ROUND: u32 = 0x0200_0000;
+
+    pub const FLAGS_START_CAP_MASK: u32 = 0x0C00_0000;
+    pub const FLAGS_END_CAP_MASK: u32 = 0x0300_0000;
+    pub const MITER_LIMIT_MASK: u32 = 0xFFFF;
+
+    pub fn from_fill(fill: Fill) -> Self {
+        let fill_bit = match fill {
+            Fill::NonZero => 0,
+            Fill::EvenOdd => Self::FLAGS_FILL_BIT,
+        };
+        Self {
+            flags_and_miter_limit: fill_bit,
+            line_width: 0.,
+        }
+    }
+
+    pub fn from_stroke(stroke: &Stroke) -> Self {
+        let style = Self::FLAGS_STYLE_BIT;
+        let join = match stroke.join {
+            Join::Bevel => Self::FLAGS_JOIN_BITS_BEVEL,
+            Join::Miter => Self::FLAGS_JOIN_BITS_MITER,
+            Join::Round => Self::FLAGS_JOIN_BITS_ROUND,
+        };
+        let start_cap = match stroke.start_cap {
+            Cap::Butt => Self::FLAGS_START_CAP_BITS_BUTT,
+            Cap::Square => Self::FLAGS_START_CAP_BITS_SQUARE,
+            Cap::Round => Self::FLAGS_START_CAP_BITS_ROUND,
+        };
+        let end_cap = match stroke.end_cap {
+            Cap::Butt => Self::FLAGS_END_CAP_BITS_BUTT,
+            Cap::Square => Self::FLAGS_END_CAP_BITS_SQUARE,
+            Cap::Round => Self::FLAGS_END_CAP_BITS_ROUND,
+        };
+        let miter_limit = crate::math::f32_to_f16(stroke.miter_limit as f32) as u32;
+        Self {
+            flags_and_miter_limit: style | join | start_cap | end_cap | miter_limit,
+            line_width: stroke.width as f32,
+        }
+    }
+
+    #[cfg(test)]
+    fn fill(&self) -> Option<Fill> {
+        if self.is_fill() {
+            Some(
+                if (self.flags_and_miter_limit & Self::FLAGS_FILL_BIT) == 0 {
+                    Fill::NonZero
+                } else {
+                    Fill::EvenOdd
+                },
+            )
+        } else {
+            None
+        }
+    }
+
+    #[cfg(test)]
+    fn stroke_width(&self) -> Option<f64> {
+        if self.is_fill() {
+            return None;
+        }
+        Some(self.line_width.into())
+    }
+
+    #[cfg(test)]
+    fn stroke_join(&self) -> Option<Join> {
+        if self.is_fill() {
+            return None;
+        }
+        let join = self.flags_and_miter_limit & Self::FLAGS_JOIN_MASK;
+        Some(match join {
+            Self::FLAGS_JOIN_BITS_BEVEL => Join::Bevel,
+            Self::FLAGS_JOIN_BITS_MITER => Join::Miter,
+            Self::FLAGS_JOIN_BITS_ROUND => Join::Round,
+            _ => unreachable!("unsupported join encoding"),
+        })
+    }
+
+    #[cfg(test)]
+    fn stroke_start_cap(&self) -> Option<Cap> {
+        if self.is_fill() {
+            return None;
+        }
+        let cap = self.flags_and_miter_limit & Self::FLAGS_START_CAP_MASK;
+        Some(match cap {
+            Self::FLAGS_START_CAP_BITS_BUTT => Cap::Butt,
+            Self::FLAGS_START_CAP_BITS_SQUARE => Cap::Square,
+            Self::FLAGS_START_CAP_BITS_ROUND => Cap::Round,
+            _ => unreachable!("unsupported start cap encoding"),
+        })
+    }
+
+    #[cfg(test)]
+    fn stroke_end_cap(&self) -> Option<Cap> {
+        if self.is_fill() {
+            return None;
+        }
+        let cap = self.flags_and_miter_limit & Self::FLAGS_END_CAP_MASK;
+        Some(match cap {
+            Self::FLAGS_END_CAP_BITS_BUTT => Cap::Butt,
+            Self::FLAGS_END_CAP_BITS_SQUARE => Cap::Square,
+            Self::FLAGS_END_CAP_BITS_ROUND => Cap::Round,
+            _ => unreachable!("unsupported end cap encoding"),
+        })
+    }
+
+    #[cfg(test)]
+    fn stroke_miter_limit(&self) -> Option<u16> {
+        if self.is_fill() {
+            return None;
+        }
+        Some((self.flags_and_miter_limit & Self::MITER_LIMIT_MASK) as u16)
+    }
+
+    #[cfg(test)]
+    fn is_fill(&self) -> bool {
+        (self.flags_and_miter_limit & Self::FLAGS_STYLE_BIT) == 0
+    }
+}
+
 /// Line segment (after flattening, before tiling).
 #[derive(Clone, Copy, Debug, Zeroable, Pod, Default)]
 #[repr(C)]
@@ -93,8 +268,8 @@ impl PathTag {
     /// Path marker.
     pub const PATH: Self = Self(0x10);
 
-    /// Line width setting.
-    pub const LINEWIDTH: Self = Self(0x40);
+    /// Style setting.
+    pub const STYLE: Self = Self(0x40);
 
     /// Bit for path segments that are represented as f32 values. If unset
     /// they are represented as i16.
@@ -142,8 +317,8 @@ pub struct PathMonoid {
     pub pathseg_ix: u32,
     /// Offset into path segment stream.
     pub pathseg_offset: u32,
-    /// Index into linewidth stream.
-    pub linewidth_ix: u32,
+    /// Index into style stream.
+    pub style_ix: u32,
     /// Index of containing path.
     pub path_ix: u32,
 }
@@ -163,7 +338,8 @@ impl Monoid for PathMonoid {
         a += a >> 16;
         c.pathseg_offset = a & 0xff;
         c.path_ix = (tag_word & (PathTag::PATH.0 as u32 * 0x1010101)).count_ones();
-        c.linewidth_ix = (tag_word & (PathTag::LINEWIDTH.0 as u32 * 0x1010101)).count_ones();
+        let style_size = (std::mem::size_of::<Style>() / std::mem::size_of::<u32>()) as u32;
+        c.style_ix = (tag_word & (PathTag::STYLE.0 as u32 * 0x1010101)).count_ones() * style_size;
         c
     }
 
@@ -173,7 +349,7 @@ impl Monoid for PathMonoid {
             trans_ix: self.trans_ix + other.trans_ix,
             pathseg_ix: self.pathseg_ix + other.pathseg_ix,
             pathseg_offset: self.pathseg_offset + other.pathseg_offset,
-            linewidth_ix: self.linewidth_ix + other.linewidth_ix,
+            style_ix: self.style_ix + other.style_ix,
             path_ix: self.path_ix + other.path_ix,
         }
     }
@@ -450,3 +626,40 @@ impl fello::scale::Pen for PathEncoder<'_> {
         self.close()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fill_style() {
+        assert_eq!(Some(Fill::NonZero), Style::from_fill(Fill::NonZero).fill());
+        assert_eq!(Some(Fill::EvenOdd), Style::from_fill(Fill::EvenOdd).fill());
+        assert_eq!(None, Style::from_stroke(&Stroke::default()).fill());
+    }
+
+    #[test]
+    fn test_stroke_style() {
+        assert_eq!(None, Style::from_fill(Fill::NonZero).stroke_width());
+        assert_eq!(None, Style::from_fill(Fill::EvenOdd).stroke_width());
+        let caps = [Cap::Butt, Cap::Square, Cap::Round];
+        let joins = [Join::Bevel, Join::Miter, Join::Round];
+        for start in caps {
+            for end in caps {
+                for join in joins {
+                    let stroke = Stroke::new(1.0)
+                        .with_start_cap(start)
+                        .with_end_cap(end)
+                        .with_join(join)
+                        .with_miter_limit(0.);
+                    let encoded = Style::from_stroke(&stroke);
+                    assert_eq!(Some(stroke.width), encoded.stroke_width());
+                    assert_eq!(Some(stroke.join), encoded.stroke_join());
+                    assert_eq!(Some(stroke.start_cap), encoded.stroke_start_cap());
+                    assert_eq!(Some(stroke.end_cap), encoded.stroke_end_cap());
+                    assert_eq!(Some(0), encoded.stroke_miter_limit());
+                }
+            }
+        }
+    }
+}
diff --git a/crates/encoding/src/resolve.rs b/crates/encoding/src/resolve.rs
index dfd89bc8d..367f40088 100644
--- a/crates/encoding/src/resolve.rs
+++ b/crates/encoding/src/resolve.rs
@@ -3,7 +3,7 @@
 
 use bytemuck::{Pod, Zeroable};
 
-use super::{DrawTag, Encoding, PathTag, StreamOffsets, Transform};
+use super::{DrawTag, Encoding, PathTag, StreamOffsets, Style, Transform};
 
 #[cfg(feature = "full")]
 use {
@@ -38,8 +38,8 @@ pub struct Layout {
     pub draw_data_base: u32,
     /// Start of transform stream.
     pub transform_base: u32,
-    /// Start of linewidth stream.
-    pub linewidth_base: u32,
+    /// Start of style stream.
+    pub style_base: u32,
 }
 
 impl Layout {
@@ -92,13 +92,13 @@ impl Layout {
     /// Returns the transform stream.
     pub fn transforms<'a>(&self, data: &'a [u8]) -> &'a [Transform] {
         let start = self.transform_base as usize * 4;
-        let end = self.linewidth_base as usize * 4;
+        let end = self.style_base as usize * 4;
         bytemuck::cast_slice(&data[start..end])
     }
 
-    /// Returns the linewidth stream.
-    pub fn linewidths<'a>(&self, data: &'a [u8]) -> &'a [f32] {
-        let start = self.linewidth_base as usize * 4;
+    /// Returns the style stream.
+    pub fn styles<'a>(&self, data: &'a [u8]) -> &'a [Style] {
+        let start = self.style_base as usize * 4;
         bytemuck::cast_slice(&data[start..])
     }
 }
@@ -150,9 +150,9 @@ pub fn resolve_solid_paths_only(encoding: &Encoding, packed: &mut Vec<u8>) -> La
     // Transform stream
     layout.transform_base = size_to_words(data.len());
     data.extend_from_slice(bytemuck::cast_slice(&encoding.transforms));
-    // Linewidth stream
-    layout.linewidth_base = size_to_words(data.len());
-    data.extend_from_slice(bytemuck::cast_slice(&encoding.linewidths));
+    // Style stream
+    layout.style_base = size_to_words(data.len());
+    data.extend_from_slice(bytemuck::cast_slice(&encoding.styles));
     layout.n_draw_objects = layout.n_paths;
     assert_eq!(buffer_size, data.len());
     layout
@@ -359,21 +359,21 @@ impl Resolver {
                 data.extend_from_slice(bytemuck::cast_slice(&stream[pos..]));
             }
         }
-        // Linewidth stream
-        layout.linewidth_base = size_to_words(data.len());
+        // Style stream
+        layout.style_base = size_to_words(data.len());
         {
             let mut pos = 0;
-            let stream = &encoding.linewidths;
+            let stream = &encoding.styles;
             for patch in &self.patches {
                 if let ResolvedPatch::GlyphRun { index, glyphs, .. } = patch {
-                    let stream_offset = resources.glyph_runs[*index].stream_offsets.linewidths;
+                    let stream_offset = resources.glyph_runs[*index].stream_offsets.styles;
                     if pos < stream_offset {
                         data.extend_from_slice(bytemuck::cast_slice(&stream[pos..stream_offset]));
                         pos = stream_offset;
                     }
                     for glyph in &self.glyph_ranges[glyphs.clone()] {
-                        let glyph_data = &self.glyph_cache.encoding.linewidths
-                            [glyph.start.linewidths..glyph.end.linewidths];
+                        let glyph_data =
+                            &self.glyph_cache.encoding.styles[glyph.start.styles..glyph.end.styles];
                         data.extend_from_slice(bytemuck::cast_slice(glyph_data));
                     }
                 }
@@ -612,7 +612,7 @@ impl SceneBufferSizes {
             )
             + slice_size_in_bytes(&encoding.draw_data, patch_sizes.draw_data)
             + slice_size_in_bytes(&encoding.transforms, patch_sizes.transforms)
-            + slice_size_in_bytes(&encoding.linewidths, patch_sizes.linewidths);
+            + slice_size_in_bytes(&encoding.styles, patch_sizes.styles);
         Self {
             buffer_size,
             path_tag_padded,
diff --git a/examples/scenes/src/test_scenes.rs b/examples/scenes/src/test_scenes.rs
index fcb4d7656..89606caf4 100644
--- a/examples/scenes/src/test_scenes.rs
+++ b/examples/scenes/src/test_scenes.rs
@@ -32,10 +32,10 @@ macro_rules! scene {
 pub fn test_scenes() -> SceneSet {
     let scenes = vec![
         scene!(splash_with_tiger(), "splash_with_tiger", false),
-        scene!(crate::mmark::MMark::new(80_000), "mmark", false),
         scene!(funky_paths),
         scene!(stroke_styles),
         scene!(tricky_strokes),
+        scene!(fill_types),
         scene!(cardioid_and_friends),
         scene!(animated_text: animated),
         scene!(gradient_extend),
@@ -48,6 +48,7 @@ pub fn test_scenes() -> SceneSet {
         scene!(clip_test: animated),
         scene!(longpathdash(Cap::Butt), "longpathdash (butt caps)", false),
         scene!(longpathdash(Cap::Round), "longpathdash (round caps)", false),
+        scene!(crate::mmark::MMark::new(80_000), "mmark", false),
     ];
 
     SceneSet { scenes }
@@ -282,6 +283,54 @@ fn tricky_strokes(sb: &mut SceneBuilder, _: &mut SceneParams) {
     }
 }
 
+fn fill_types(sb: &mut SceneBuilder, params: &mut SceneParams) {
+    use PathEl::*;
+    let rect = Rect::from_origin_size(Point::new(0., 0.), (500., 500.));
+    let star = [
+        MoveTo((250., 0.).into()),
+        LineTo((105., 450.).into()),
+        LineTo((490., 175.).into()),
+        LineTo((10., 175.).into()),
+        LineTo((395., 450.).into()),
+        ClosePath,
+    ];
+    let arcs = [
+        MoveTo((0., 480.).into()),
+        CurveTo((500., 480.).into(), (500., -10.).into(), (0., -10.).into()),
+        ClosePath,
+        MoveTo((500., -10.).into()),
+        CurveTo((0., -10.).into(), (0., 480.).into(), (500., 480.).into()),
+        ClosePath,
+    ];
+    let scale = Affine::scale(0.6);
+    let t = Affine::translate((10., 25.));
+    let rules = [
+        (Fill::NonZero, "Non-Zero", star.as_slice()),
+        (Fill::EvenOdd, "Even-Odd", &star),
+        (Fill::NonZero, "Non-Zero", &arcs),
+        (Fill::EvenOdd, "Even-Odd", &arcs),
+    ];
+    for (i, rule) in rules.iter().enumerate() {
+        let t = Affine::translate(((i % 2) as f64 * 306., (i / 2) as f64 * 340.)) * t;
+        params.text.add(sb, None, 24., None, t, rule.1);
+        let t = Affine::translate((0., 5.)) * t * scale;
+        sb.fill(
+            Fill::NonZero,
+            t,
+            &Brush::Solid(Color::rgb8(128, 128, 128)),
+            None,
+            &rect,
+        );
+        sb.fill(
+            rule.0,
+            Affine::translate((0., 10.)) * t,
+            Color::BLACK,
+            None,
+            &rule.2,
+        );
+    }
+}
+
 fn cardioid_and_friends(sb: &mut SceneBuilder, _: &mut SceneParams) {
     render_cardioid(sb);
     render_clip_test(sb);
diff --git a/shader/flatten.wgsl b/shader/flatten.wgsl
index e27bb6ed1..a5d328f09 100644
--- a/shader/flatten.wgsl
+++ b/shader/flatten.wgsl
@@ -218,7 +218,13 @@ fn main(
     var tag_byte = (tag_word >> shift) & 0xffu;
 
     let out = &path_bboxes[tm.path_ix];
-    let linewidth = bitcast<f32>(scene[config.linewidth_base + tm.linewidth_ix]);
+    let style_flags = scene[config.style_base + tm.style_ix];
+    // TODO: We assume all paths are fills at the moment. This is where we will extract the stroke
+    // vs fill state using STYLE_FLAGS_STYLE_BIT.
+    // TODO: The downstream pipelines still use the old floating-point linewidth/fill encoding scheme
+    // This will change to represent the fill rule as a single bit inside the bounding box and draw
+    // info data structures.
+    let linewidth = select(-2.0, -1.0, (style_flags & STYLE_FLAGS_FILL_BIT) == 0u);
     if (tag_byte & PATH_TAG_PATH) != 0u {
         (*out).linewidth = linewidth;
         (*out).trans_ix = tm.trans_ix;
diff --git a/shader/shared/config.wgsl b/shader/shared/config.wgsl
index 1e553f9ae..fcae33c88 100644
--- a/shader/shared/config.wgsl
+++ b/shader/shared/config.wgsl
@@ -29,7 +29,7 @@ struct Config {
     drawdata_base: u32,
 
     transform_base: u32,
-    linewidth_base: u32,
+    style_base: u32,
 
     // Sizes of bump allocated buffers (in element size units)
     binning_size: u32,
diff --git a/shader/shared/pathtag.wgsl b/shader/shared/pathtag.wgsl
index 9777f47d3..0aa942d90 100644
--- a/shader/shared/pathtag.wgsl
+++ b/shader/shared/pathtag.wgsl
@@ -6,7 +6,7 @@ struct TagMonoid {
     pathseg_ix: u32,
     pathseg_offset: u32,
 #ifdef full
-    linewidth_ix: u32,
+    style_ix: u32,
     path_ix: u32,
 #endif
 }
@@ -19,9 +19,16 @@ let PATH_TAG_F32 = 8u;
 let PATH_TAG_TRANSFORM = 0x20u;
 #ifdef full
 let PATH_TAG_PATH = 0x10u;
-let PATH_TAG_LINEWIDTH = 0x40u;
+let PATH_TAG_STYLE = 0x40u;
 #endif
 
+// Size of the `Style` data structure in words
+let STYLE_SIZE_IN_WORDS: u32 = 2u;
+let STYLE_FLAGS_STYLE_BIT: u32 = 0x80000000u;
+let STYLE_FLAGS_FILL_BIT: u32 = 0x40000000u;
+
+// TODO: Declare the remaining STYLE flags here.
+
 fn tag_monoid_identity() -> TagMonoid {
     return TagMonoid();
 }
@@ -32,7 +39,7 @@ fn combine_tag_monoid(a: TagMonoid, b: TagMonoid) -> TagMonoid {
     c.pathseg_ix = a.pathseg_ix + b.pathseg_ix;
     c.pathseg_offset = a.pathseg_offset + b.pathseg_offset;
 #ifdef full
-    c.linewidth_ix = a.linewidth_ix + b.linewidth_ix;
+    c.style_ix = a.style_ix + b.style_ix;
     c.path_ix = a.path_ix + b.path_ix;
 #endif
     return c;
@@ -50,7 +57,7 @@ fn reduce_tag(tag_word: u32) -> TagMonoid {
     c.pathseg_offset = a & 0xffu;
 #ifdef full
     c.path_ix = countOneBits(tag_word & (PATH_TAG_PATH * 0x1010101u));
-    c.linewidth_ix = countOneBits(tag_word & (PATH_TAG_LINEWIDTH * 0x1010101u));
+    c.style_ix = countOneBits(tag_word & (PATH_TAG_STYLE * 0x1010101u)) * STYLE_SIZE_IN_WORDS;
 #endif
     return c;
 }
diff --git a/src/cpu_shader/flatten.rs b/src/cpu_shader/flatten.rs
index 2cdf7256b..150aec174 100644
--- a/src/cpu_shader/flatten.rs
+++ b/src/cpu_shader/flatten.rs
@@ -4,7 +4,9 @@
 use crate::cpu_dispatch::CpuBinding;
 
 use super::util::{Transform, Vec2};
-use vello_encoding::{BumpAllocators, ConfigUniform, LineSoup, Monoid, PathBbox, PathMonoid};
+use vello_encoding::{
+    BumpAllocators, ConfigUniform, LineSoup, Monoid, PathBbox, PathMonoid, Style,
+};
 
 fn to_minus_one_quarter(x: f32) -> f32 {
     // could also be written x.powf(-0.25)
@@ -211,11 +213,19 @@ fn flatten_main(
         if tag_byte != 0 {
             tm = tag_monoids[ix >> 2].combine(&tm);
         }
-        let linewidth =
-            f32::from_bits(scene[(config.layout.linewidth_base + tm.linewidth_ix) as usize]);
+        let style_flags = scene[(config.layout.style_base + tm.style_ix) as usize];
         if (tag_byte & PATH_TAG_PATH) != 0 {
             let out = &mut path_bboxes[tm.path_ix as usize];
-            out.linewidth = linewidth;
+            // TODO: We assume all paths are fills at the moment. This is where we will extract the
+            // stroke vs fill state using STYLE_FLAGS_STYLE_BIT.
+            // TODO: The downstream pipelines still use the old floating-point linewidth/fill
+            // encoding scheme. This will change to represent the fill rule as a single bit inside
+            // the bounding box and draw info data structures.
+            out.linewidth = if (style_flags & Style::FLAGS_FILL_BIT) == 0 {
+                -1.0
+            } else {
+                -2.0
+            };
             out.trans_ix = tm.trans_ix;
         }
         let seg_type = tag_byte & PATH_TAG_SEG_TYPE;