diff --git a/.rive_head b/.rive_head
index ec72cc2..2cc4a4c 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-0ffa502c470709177f941dca669e3a9cfb9612bf
+291a3a02bce12a2c92a456f6a71ad3a410162f0f
diff --git a/build.sh b/build.sh
index 1534111..f6430b7 100755
--- a/build.sh
+++ b/build.sh
@@ -1,6 +1,7 @@
 #!/bin/bash
-set -e 
+set -e
 
+source dependencies/config_directories.sh
 pushd build &>/dev/null
 
 while getopts p: flag; do
diff --git a/build/dependency.lua b/build/dependency.lua
new file mode 100644
index 0000000..bef9145
--- /dev/null
+++ b/build/dependency.lua
@@ -0,0 +1,49 @@
+local m = {}
+
+local last_str = ''
+
+function iop(str)
+    io.write(('\b \b'):rep(#last_str)) -- erase old line
+    io.write(str) -- write new line
+    io.flush()
+    last_str = str
+end
+
+function m.github(project, tag)
+    local dependencies = os.getenv('DEPENDENCIES')
+    if dependencies == nil then
+        dependencies = path.getabsolute(_WORKING_DIR) .. '/dependencies'
+        os.mkdir(dependencies)
+    end
+    local hash = string.sha1(project .. tag)
+    if not os.isdir(dependencies .. '/' .. hash) then
+        function progress(total, current)
+            local ratio = current / total
+            ratio = math.min(math.max(ratio, 0), 1)
+            local percent = math.floor(ratio * 100)
+            if total == current then
+                iop('')
+            else
+                iop('Downloading ' .. project .. ' ' .. percent .. '%')
+            end
+        end
+
+        local downloadFilename = dependencies .. '/' .. hash .. '.zip'
+        http.download(
+            'https://github.com/' .. project .. '/archive/' .. tag .. '.zip',
+            downloadFilename,
+            {progress = progress}
+        )
+        print('Downloaded ' .. project .. '.')
+        zip.extract(downloadFilename, dependencies .. '/' .. hash)
+        os.remove(downloadFilename)
+    end
+    local dirs = os.matchdirs(dependencies .. '/' .. hash .. '/*')
+
+    local iter = pairs(dirs)
+    local currentKey, currentValue = iter(dirs)
+    print('Dependency ' .. project .. ' located at:')
+    print('  ' .. currentValue)
+    return currentValue
+end
+return m
diff --git a/build/premake5.lua b/build/premake5.lua
index 9cafaf2..507d7c2 100644
--- a/build/premake5.lua
+++ b/build/premake5.lua
@@ -4,11 +4,14 @@
 do
     defines {'WITH_RIVE_TOOLS'}
 end
-filter {'options:with_rive_tools'}
+filter {'options:with_rive_text'}
 do
-    defines {'WITH_RIVE_TOOLS'}
+    defines {'WITH_RIVE_TEXT'}
 end
 
+dofile(path.join(path.getabsolute('../dependencies/'), 'premake5_harfbuzz.lua'))
+dofile(path.join(path.getabsolute('../dependencies/'), 'premake5_sheenbidi.lua'))
+
 WINDOWS_CLANG_CL_SUPPRESSED_WARNINGS = {
     '-Wno-c++98-compat',
     '-Wno-c++98-compat-pedantic',
@@ -28,7 +31,9 @@
     '-Wno-sign-compare',
     '-Wno-sign-conversion',
     '-Wno-unused-macros',
-    '-Wno-unused-parameter'
+    '-Wno-unused-parameter',
+    '-Wno-switch-enum',
+    '-Wno-missing-field-initializers'
 }
 
 project 'rive'
@@ -39,7 +44,11 @@
     toolset 'clang'
     targetdir '%{cfg.system}/bin/%{cfg.buildcfg}'
     objdir '%{cfg.system}/obj/%{cfg.buildcfg}'
-    includedirs {'../include'}
+    includedirs {
+        '../include',
+        harfbuzz .. '/src',
+        sheenbidi .. '/Headers'
+    }
 
     files {'../src/**.cpp'}
 
diff --git a/dependencies/linux/get_harfbuzz.sh b/dependencies/linux/get_harfbuzz.sh
deleted file mode 120000
index 994888b..0000000
--- a/dependencies/linux/get_harfbuzz.sh
+++ /dev/null
@@ -1 +0,0 @@
-../macosx/get_harfbuzz.sh
\ No newline at end of file
diff --git a/dependencies/macosx/get_harfbuzz.sh b/dependencies/macosx/get_harfbuzz.sh
deleted file mode 100755
index 6ad6b12..0000000
--- a/dependencies/macosx/get_harfbuzz.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-# if you're looking at this in dependencies/linux, please note it's a symbolic
-# link to dependencies/macosx/get_harfbuzz.sh if changes need to be made here we
-# should let these two scripts diverge.
-set -e
-
-if [ -z "${DEPENDENCIES}" ]; then
-    echo "DEPENDENCIES env variable must be set. This script is usually called by other scripts."
-    exit 1
-fi
-pushd $DEPENDENCIES
-
-if [ ! -d harfbuzz ]; then
-    echo "Cloning Harfbuzz."
-    git clone https://github.com/harfbuzz/harfbuzz
-    cd harfbuzz
-    git checkout 858570b1d9912a1b746ab39fbe62a646c4f7a5b1 .
-fi
diff --git a/dependencies/premake5_harfbuzz.lua b/dependencies/premake5_harfbuzz.lua
index 9c31248..3fefe81 100644
--- a/dependencies/premake5_harfbuzz.lua
+++ b/dependencies/premake5_harfbuzz.lua
@@ -1,6 +1,5 @@
-dependencies = os.getenv('DEPENDENCIES')
-
-harfbuzz = dependencies .. '/harfbuzz'
+local dependency = require 'dependency'
+harfbuzz = dependency.github('harfbuzz/harfbuzz', '858570b1d9912a1b746ab39fbe62a646c4f7a5b1')
 
 workspace 'rive'
 configurations {'debug', 'release'}
diff --git a/dependencies/premake5_sheenbidi.lua b/dependencies/premake5_sheenbidi.lua
new file mode 100644
index 0000000..bebb582
--- /dev/null
+++ b/dependencies/premake5_sheenbidi.lua
@@ -0,0 +1,116 @@
+local dependency = require 'dependency'
+sheenbidi = dependency.github('Tehreer/SheenBidi', 'v2.6')
+
+workspace 'rive'
+configurations {'debug', 'release'}
+
+project 'rive_sheenbidi'
+do
+    kind 'StaticLib'
+    language 'C'
+    toolset 'clang'
+    targetdir '%{cfg.system}/cache/bin/%{cfg.buildcfg}/'
+    objdir '%{cfg.system}/cache/obj/%{cfg.buildcfg}/'
+
+    includedirs {
+        sheenbidi .. '/Headers'
+    }
+
+    filter 'configurations:debug'
+    do
+        files {
+            sheenbidi .. '/Source/BidiChain.c',
+            sheenbidi .. '/Source/BidiTypeLookup.c',
+            sheenbidi .. '/Source/BracketQueue.c',
+            sheenbidi .. '/Source/GeneralCategoryLookup.c',
+            sheenbidi .. '/Source/IsolatingRun.c',
+            sheenbidi .. '/Source/LevelRun.c',
+            sheenbidi .. '/Source/PairingLookup.c',
+            sheenbidi .. '/Source/RunQueue.c',
+            sheenbidi .. '/Source/SBAlgorithm.c',
+            sheenbidi .. '/Source/SBBase.c',
+            sheenbidi .. '/Source/SBCodepointSequence.c',
+            sheenbidi .. '/Source/SBLine.c',
+            sheenbidi .. '/Source/SBLog.c',
+            sheenbidi .. '/Source/SBMirrorLocator.c',
+            sheenbidi .. '/Source/SBParagraph.c',
+            sheenbidi .. '/Source/SBScriptLocator.c',
+            sheenbidi .. '/Source/ScriptLookup.c',
+            sheenbidi .. '/Source/ScriptStack.c',
+            sheenbidi .. '/Source/StatusStack.c'
+        }
+    end
+    filter 'configurations:release'
+    do
+        files {
+            sheenbidi .. '/Source/SheenBidi.c'
+        }
+    end
+
+    buildoptions {
+        '-Wall',
+        '-ansi',
+        '-pedantic'
+    }
+
+    linkoptions {'-r'}
+
+    filter 'configurations:debug'
+    do
+        buildoptions {'-g', '-O0'}
+        defines {'DEBUG'}
+        symbols 'On'
+    end
+
+    filter 'configurations:release'
+    do
+        buildoptions {'-Oz'}
+        defines {'RELEASE', 'NDEBUG', 'SB_CONFIG_UNITY'}
+        optimize 'On'
+    end
+
+    filter 'system:windows'
+    do
+        removebuildoptions {
+            -- vs clang doesn't recognize these on windows
+            '-fno-exceptions',
+            '-fno-rtti'
+        }
+        architecture 'x64'
+        buildoptions {
+            '-Wno-c++98-compat',
+            '-Wno-c++98-compat-pedantic',
+            '-Wno-c99-extensions',
+            '-Wno-ctad-maybe-unsupported',
+            '-Wno-deprecated-copy-with-user-provided-dtor',
+            '-Wno-deprecated-declarations',
+            '-Wno-documentation',
+            '-Wno-documentation-pedantic',
+            '-Wno-documentation-unknown-command',
+            '-Wno-double-promotion',
+            '-Wno-exit-time-destructors',
+            '-Wno-float-equal',
+            '-Wno-global-constructors',
+            '-Wno-implicit-float-conversion',
+            '-Wno-newline-eof',
+            '-Wno-old-style-cast',
+            '-Wno-reserved-identifier',
+            '-Wno-shadow',
+            '-Wno-sign-compare',
+            '-Wno-sign-conversion',
+            '-Wno-unused-macros',
+            '-Wno-unused-parameter',
+            '-Wno-used-but-marked-unused',
+            '-Wno-cast-qual',
+            '-Wno-unused-template',
+            '-Wno-zero-as-null-pointer-constant',
+            '-Wno-extra-semi',
+            '-Wno-undef',
+            '-Wno-comma',
+            '-Wno-nonportable-system-include-path',
+            '-Wno-covered-switch-default',
+            '-Wno-microsoft-enum-value',
+            '-Wno-deprecated-declarations'
+        }
+    end
+end
diff --git a/dependencies/windows/get_harfbuzz.bat b/dependencies/windows/get_harfbuzz.bat
deleted file mode 100644
index e225413..0000000
--- a/dependencies/windows/get_harfbuzz.bat
+++ /dev/null
@@ -1,11 +0,0 @@
-@echo off
-pushd %DEPENDENCIES%
-@echo off
-if not exist ".\harfbuzz" (
-    echo "Cloning Harfbuzz."
-    git clone https://github.com/harfbuzz/harfbuzz
-    pushd harfbuzz
-    git checkout 858570b1d9912a1b746ab39fbe62a646c4f7a5b1 .
-    popd
-)
-popd
\ No newline at end of file
diff --git a/dev/test.bat b/dev/test.bat
index a238f75..3846a44 100644
--- a/dev/test.bat
+++ b/dev/test.bat
@@ -7,15 +7,9 @@
     popd
 )
 
-if not exist "%DEPENDENCIES%\harfbuzz\" (
-    pushd "%DEPENDENCIES_SCRIPTS%"
-    call .\get_harfbuzz.bat || goto :error
-    popd
-)
-
 set "PREMAKE=%DEPENDENCIES%\bin\premake5.exe"
 pushd test
-%PREMAKE% vs2022
+%PREMAKE% --scripts=..\..\build vs2022
 
 MSBuild.exe /?  2> NUL
 if not %ERRORLEVEL%==9009 (
diff --git a/dev/test.sh b/dev/test.sh
index 3a0ea33..2707558 100755
--- a/dev/test.sh
+++ b/dev/test.sh
@@ -8,19 +8,13 @@
 OPTION=$1
 UTILITY=
 
-if [[ ! -d "$DEPENDENCIES/harfbuzz" ]]; then
-  pushd $DEPENDENCIES_SCRIPTS
-  ./get_harfbuzz.sh
-  popd
-fi
-
 if [ "$OPTION" = "help" ]; then
   echo test.sh - run the tests
   echo test.sh clean - clean and run the tests
   exit
 elif [ "$OPTION" = "clean" ]; then
   echo Cleaning project ...
-  premake5 clean || exit 1
+  premake5 --scripts=../../build clean || exit 1
   shift
 elif [ "$OPTION" = "memory" ]; then
   echo Will perform memory checks...
@@ -32,7 +26,7 @@
   shift
 fi
 
-premake5 gmake2 || exit 1
+premake5 --scripts=../../build gmake2 || exit 1
 make -j7 || exit 1
 
 for file in ./build/bin/debug/*; do
diff --git a/dev/test/premake5.lua b/dev/test/premake5.lua
index 07a3d35..501c4f6 100644
--- a/dev/test/premake5.lua
+++ b/dev/test/premake5.lua
@@ -16,8 +16,8 @@
 workspace 'rive'
 configurations {'debug'}
 
-dependencies = os.getenv('DEPENDENCIES')
-dofile(path.join(path.getabsolute(dependencies) .. '/../..', 'premake5_harfbuzz.lua'))
+dofile(path.join(path.getabsolute('../../dependencies/'), 'premake5_harfbuzz.lua'))
+dofile(path.join(path.getabsolute('../../dependencies/'), 'premake5_sheenbidi.lua'))
 
 project('tests')
 do
@@ -30,9 +30,15 @@
 
     buildoptions {'-Wall', '-fno-exceptions', '-fno-rtti'}
 
-    includedirs {'./include', '../../include', dependencies .. '/harfbuzz/src'}
+    includedirs {
+        './include',
+        '../../include',
+        harfbuzz .. '/src',
+        sheenbidi .. '/Headers'
+    }
     links {
-        'rive_harfbuzz'
+        'rive_harfbuzz',
+        'rive_sheenbidi'
     }
 
     files {
@@ -86,7 +92,9 @@
             '-Wno-unused-macros',
             '-Wno-unused-parameter',
             '-Wno-four-char-constants',
-            '-Wno-unreachable-code'
+            '-Wno-unreachable-code',
+            '-Wno-switch-enum',
+            '-Wno-missing-field-initializers'
         }
     end
 end
diff --git a/include/rive/factory.hpp b/include/rive/factory.hpp
index fd0232d..6d69bad 100644
--- a/include/rive/factory.hpp
+++ b/include/rive/factory.hpp
@@ -6,7 +6,7 @@
 #define _RIVE_FACTORY_HPP_
 
 #include "rive/renderer.hpp"
-#include "rive/render_text.hpp"
+#include "rive/text.hpp"
 #include "rive/refcnt.hpp"
 #include "rive/span.hpp"
 #include "rive/math/aabb.hpp"
@@ -58,7 +58,7 @@
 
     virtual std::unique_ptr<RenderImage> decodeImage(Span<const uint8_t>) = 0;
 
-    virtual rcp<RenderFont> decodeFont(Span<const uint8_t>) { return nullptr; }
+    virtual rcp<Font> decodeFont(Span<const uint8_t>) { return nullptr; }
 
     // Non-virtual helpers
 
diff --git a/include/rive/render_text.hpp b/include/rive/render_text.hpp
deleted file mode 100644
index d7827ed..0000000
--- a/include/rive/render_text.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#ifndef _RIVE_RENDER_TEXT_HPP_
-#define _RIVE_RENDER_TEXT_HPP_
-
-#include "rive/math/raw_path.hpp"
-#include "rive/refcnt.hpp"
-#include "rive/span.hpp"
-#include "rive/simple_array.hpp"
-
-namespace rive
-{
-
-using Unichar = uint32_t;
-using GlyphID = uint16_t;
-
-struct RenderTextRun;
-struct RenderGlyphRun;
-
-class RenderFont : public RefCnt<RenderFont>
-{
-public:
-    virtual ~RenderFont() {}
-
-    struct LineMetrics
-    {
-        float ascent, descent;
-    };
-
-    const LineMetrics& lineMetrics() const { return m_LineMetrics; }
-
-    // This is experimental
-    // -- may only be needed by Editor
-    // -- so it may be removed from here later
-    //
-    struct Axis
-    {
-        uint32_t tag;
-        float min;
-        float def; // default value
-        float max;
-    };
-
-    // Returns the canonical set of Axes for this font. Use this to know
-    // what variations are possible. If you want to know the specific
-    // coordinate within that variations space for *this* font, call
-    // getCoords().
-    //
-    virtual std::vector<Axis> getAxes() const = 0;
-
-    struct Coord
-    {
-        uint32_t axis;
-        float value;
-    };
-
-    // Returns the specific coords in variation space for this font.
-    // If you want to have a description of the entire variation space,
-    // call getAxes().
-    //
-    virtual std::vector<Coord> getCoords() const = 0;
-
-    virtual rcp<RenderFont> makeAtCoords(Span<const Coord>) const = 0;
-
-    rcp<RenderFont> makeAtCoord(Coord c) { return this->makeAtCoords(Span<const Coord>(&c, 1)); }
-
-    // Returns a 1-point path for this glyph. It will be positioned
-    // relative to (0,0) with the typographic baseline at y = 0.
-    //
-    virtual RawPath getPath(GlyphID) const = 0;
-
-    rive::SimpleArray<RenderGlyphRun> shapeText(rive::Span<const rive::Unichar> text,
-                                                rive::Span<const rive::RenderTextRun> runs) const;
-
-protected:
-    RenderFont(const LineMetrics& lm) : m_LineMetrics(lm) {}
-
-    virtual rive::SimpleArray<RenderGlyphRun>
-    onShapeText(rive::Span<const rive::Unichar> text,
-                rive::Span<const rive::RenderTextRun> runs) const = 0;
-
-private:
-    const LineMetrics m_LineMetrics;
-};
-
-struct RenderTextRun
-{
-    rcp<RenderFont> font;
-    float size;
-    uint32_t unicharCount;
-};
-
-struct RenderGlyphRun
-{
-    RenderGlyphRun(size_t glyphCount = 0) :
-        glyphs(glyphCount), textIndices(glyphCount), xpos(glyphCount + 1)
-    {}
-
-    RenderGlyphRun(rive::SimpleArray<GlyphID> glyphIds,
-                   rive::SimpleArray<uint32_t> offsets,
-                   rive::SimpleArray<float> xs) :
-        glyphs(glyphIds), textIndices(offsets), xpos(xs)
-    {}
-
-    rcp<RenderFont> font;
-    float size;
-    // List of glyphs, represented by font specific glyph ids. Length is equal to number of glyphs
-    // in the run.
-    rive::SimpleArray<GlyphID> glyphs;
-
-    // Index in the unicode text array representing the text displayed in this run. Because each
-    // glyph can be composed of multiple unicode values, this index points to the first index in the
-    // unicode text. Length is equal to number of glyphs in the run.
-    rive::SimpleArray<uint32_t> textIndices;
-
-    // X position of each glyph, with an extra value at the end for the right most extent of the
-    // last glyph.
-    rive::SimpleArray<float> xpos;
-
-    // List of possible indices to line break at. Has a stride of 2 uint32_ts where each pair marks
-    // the start and end of a word, with the exception of a return character (forced linebreak)
-    // which is represented as a 0 length word (where start/end index is the same).
-    rive::SimpleArray<uint32_t> breaks;
-};
-
-} // namespace rive
-#endif
diff --git a/include/rive/text.hpp b/include/rive/text.hpp
new file mode 100644
index 0000000..13aa7cd
--- /dev/null
+++ b/include/rive/text.hpp
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#ifndef _RIVE_TEXT_HPP_
+#define _RIVE_TEXT_HPP_
+
+#include "rive/math/raw_path.hpp"
+#include "rive/refcnt.hpp"
+#include "rive/span.hpp"
+#include "rive/simple_array.hpp"
+
+namespace rive
+{
+
+// Representation of a single unicode codepoint.
+using Unichar = uint32_t;
+// Id for a glyph within a font.
+using GlyphID = uint16_t;
+
+struct TextRun;
+struct GlyphRun;
+
+// Direction a paragraph or run flows in.
+enum class TextDirection : uint8_t
+{
+    ltr = 0,
+    rtl = 1
+};
+
+// The alignment of each word wrapped line in a paragraph.
+enum class TextAlign : uint8_t
+{
+    left = 0,
+    right = 1,
+    center = 2
+};
+
+// A horizontal line of text with a paragraph, after line-breaking.
+struct GlyphLine
+{
+    uint32_t startRunIndex;
+    uint32_t startGlyphIndex;
+    uint32_t endRunIndex;
+    uint32_t endGlyphIndex;
+    float startX;
+    float top = 0, baseline = 0, bottom = 0;
+
+    bool operator==(const GlyphLine& o) const
+    {
+        return startRunIndex == o.startRunIndex && startGlyphIndex == o.startGlyphIndex &&
+               endRunIndex == o.endRunIndex && endGlyphIndex == o.endGlyphIndex;
+    }
+
+    GlyphLine() :
+        startRunIndex(0), startGlyphIndex(0), endRunIndex(0), endGlyphIndex(0), startX(0.0f)
+    {}
+    GlyphLine(uint32_t run, uint32_t index) :
+        startRunIndex(run),
+        startGlyphIndex(index),
+        endRunIndex(run),
+        endGlyphIndex(index),
+        startX(0.0f)
+    {}
+
+    bool empty() const { return startRunIndex == endRunIndex && startGlyphIndex == endGlyphIndex; }
+
+    static SimpleArray<GlyphLine> BreakLines(Span<const GlyphRun> runs, float width);
+
+    // Compute values for top/baseline/bottom per line
+    static void
+    ComputeLineSpacing(Span<GlyphLine>, Span<const GlyphRun>, float width, TextAlign align);
+
+    static float ComputeMaxWidth(Span<GlyphLine> lines, Span<const GlyphRun> runs);
+};
+
+// A paragraph represents of set of runs that flow in a specific direction. The
+// runs are always provided in LTR and must be drawn in reverse when the
+// baseDirection is RTL. These are built by the system during shaping where the
+// user provided string and text styling is converted to shaped paragraphs.
+struct Paragraph
+{
+    SimpleArray<GlyphRun> runs;
+    TextDirection baseDirection;
+};
+
+// An abstraction for interfacing with an individual font.
+class Font : public RefCnt<Font>
+{
+public:
+    virtual ~Font() {}
+
+    struct LineMetrics
+    {
+        float ascent, descent;
+    };
+
+    const LineMetrics& lineMetrics() const { return m_LineMetrics; }
+
+    // This is experimental
+    // -- may only be needed by Editor
+    // -- so it may be removed from here later
+    //
+    struct Axis
+    {
+        uint32_t tag;
+        float min;
+        float def; // default value
+        float max;
+    };
+
+    // Returns the canonical set of Axes for this font. Use this to know
+    // what variations are possible. If you want to know the specific
+    // coordinate within that variations space for *this* font, call
+    // getCoords().
+    //
+    virtual std::vector<Axis> getAxes() const = 0;
+
+    struct Coord
+    {
+        uint32_t axis;
+        float value;
+    };
+
+    // Returns the specific coords in variation space for this font.
+    // If you want to have a description of the entire variation space,
+    // call getAxes().
+    //
+    virtual std::vector<Coord> getCoords() const = 0;
+
+    virtual rcp<Font> makeAtCoords(Span<const Coord>) const = 0;
+
+    rcp<Font> makeAtCoord(Coord c) { return this->makeAtCoords(Span<const Coord>(&c, 1)); }
+
+    // Returns a 1-point path for this glyph. It will be positioned
+    // relative to (0,0) with the typographic baseline at y = 0.
+    //
+    virtual RawPath getPath(GlyphID) const = 0;
+
+    SimpleArray<Paragraph> shapeText(Span<const Unichar> text, Span<const TextRun> runs) const;
+
+protected:
+    Font(const LineMetrics& lm) : m_LineMetrics(lm) {}
+
+    virtual SimpleArray<Paragraph> onShapeText(Span<const Unichar> text,
+                                               Span<const TextRun> runs) const = 0;
+
+private:
+    const LineMetrics m_LineMetrics;
+};
+
+// A user defined styling guide for a set of unicode codepoints within a larger text string.
+struct TextRun
+{
+    rcp<Font> font;
+    float size;
+    uint32_t unicharCount;
+    uint32_t script;
+    uint16_t styleId;
+    TextDirection dir;
+};
+
+// The corresponding system generated run for the user provided TextRuns. GlyphRuns may not match
+// TextRuns if the system needs to split the run (for fallback fonts) or if codepoints get
+// ligated/shaped to a single glyph.
+struct GlyphRun
+{
+    GlyphRun(size_t glyphCount = 0) :
+        glyphs(glyphCount), textIndices(glyphCount), advances(glyphCount), xpos(glyphCount + 1)
+    {}
+
+    GlyphRun(SimpleArray<GlyphID> glyphIds,
+             SimpleArray<uint32_t> offsets,
+             SimpleArray<float> ws,
+             SimpleArray<float> xs) :
+        glyphs(glyphIds), textIndices(offsets), advances(ws), xpos(xs)
+    {}
+
+    rcp<Font> font;
+    float size;
+
+    // List of glyphs, represented by font specific glyph ids. Length is equal to number of glyphs
+    // in the run.
+    SimpleArray<GlyphID> glyphs;
+
+    // Index in the unicode text array representing the text displayed in this run. Because each
+    // glyph can be composed of multiple unicode values, this index points to the first index in the
+    // unicode text. Length is equal to number of glyphs in the run.
+    SimpleArray<uint32_t> textIndices;
+
+    // X position of each glyph in visual order (xpos is in logical/memory order).
+    SimpleArray<float> advances;
+
+    // X position of each glyph, with an extra value at the end for the right most extent of the
+    // last glyph.
+    SimpleArray<float> xpos;
+
+    // List of possible indices to line break at. Has a stride of 2 uint32_ts where each pair marks
+    // the start and end of a word, with the exception of a return character (forced linebreak)
+    // which is represented as a 0 length word (where start/end index is the same).
+    SimpleArray<uint32_t> breaks;
+
+    // The unique identifier for the styling (fill/stroke colors, anything not determined by the
+    // font or font size) applied to this run.
+    uint16_t styleId;
+
+    // The text direction (LTR = 0/RTL = 1)
+    TextDirection dir;
+};
+
+} // namespace rive
+#endif
diff --git a/include/rive/text/font_hb.hpp b/include/rive/text/font_hb.hpp
new file mode 100644
index 0000000..d4c290f
--- /dev/null
+++ b/include/rive/text/font_hb.hpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#ifndef _RIVE_FONT_HB_HPP_
+#define _RIVE_FONT_HB_HPP_
+
+#include "rive/factory.hpp"
+#include "rive/text.hpp"
+
+struct hb_font_t;
+struct hb_draw_funcs_t;
+
+class HBFont : public rive::Font
+{
+    hb_draw_funcs_t* m_DrawFuncs;
+
+public:
+    hb_font_t* m_Font;
+
+    // We assume ownership of font!
+    HBFont(hb_font_t* font);
+    ~HBFont() override;
+
+    std::vector<Axis> getAxes() const override;
+    std::vector<Coord> getCoords() const override;
+    rive::rcp<rive::Font> makeAtCoords(rive::Span<const Coord>) const override;
+    rive::RawPath getPath(rive::GlyphID) const override;
+    rive::SimpleArray<rive::Paragraph> onShapeText(rive::Span<const rive::Unichar>,
+                                                   rive::Span<const rive::TextRun>) const override;
+
+    static rive::rcp<rive::Font> Decode(rive::Span<const uint8_t>);
+
+    // If the platform can supply fallback font(s), set this function pointer.
+    // It will be called with a span of unichars, and the platform attempts to
+    // return a font that can draw (at least some of) them. If no font is available
+    // just return nullptr.
+
+    using FallbackProc = rive::rcp<rive::Font> (*)(rive::Span<const rive::Unichar>);
+
+    static FallbackProc gFallbackProc;
+};
+
+#endif
diff --git a/include/rive/text/line_breaker.hpp b/include/rive/text/line_breaker.hpp
deleted file mode 100644
index 827873d..0000000
--- a/include/rive/text/line_breaker.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#ifndef _RIVE_RENDER_GLYPH_LINE_H_
-#define _RIVE_RENDER_GLYPH_LINE_H_
-
-#include "rive/render_text.hpp"
-
-namespace rive
-{
-
-enum class RenderTextAlign : uint8_t
-{
-    left = 0,
-    right = 1,
-    center = 2
-};
-
-struct RenderGlyphLine
-{
-    uint32_t startRun;
-    uint32_t startIndex;
-    uint32_t endRun;
-    uint32_t endIndex;
-    float startX;
-    float top = 0, baseline = 0, bottom = 0;
-
-    bool operator==(const RenderGlyphLine& o) const
-    {
-        return startRun == o.startRun && startIndex == o.startIndex && endRun == o.endRun &&
-               endIndex == o.endIndex;
-    }
-
-    RenderGlyphLine() : startRun(0), startIndex(0), endRun(0), endIndex(0), startX(0.0f) {}
-    RenderGlyphLine(uint32_t run, uint32_t index) :
-        startRun(run), startIndex(index), endRun(run), endIndex(index), startX(0.0f)
-    {}
-
-    bool empty() const { return startRun == endRun && startIndex == endIndex; }
-    static std::vector<RenderGlyphLine> BreakLines(Span<const RenderGlyphRun> runs,
-                                                   float width,
-                                                   RenderTextAlign align);
-
-    // Compute values for top/baseline/bottom per line
-    static void ComputeLineSpacing(rive::Span<RenderGlyphLine>,
-                                   rive::Span<const RenderGlyphRun>,
-                                   float width,
-                                   RenderTextAlign align);
-};
-
-} // namespace rive
-
-#endif
diff --git a/include/rive/text/renderfont_hb.hpp b/include/rive/text/renderfont_hb.hpp
deleted file mode 100644
index 865afc2..0000000
--- a/include/rive/text/renderfont_hb.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#ifndef _RIVE_RENDERFONT_HB_HPP_
-#define _RIVE_RENDERFONT_HB_HPP_
-
-#include "rive/factory.hpp"
-#include "rive/render_text.hpp"
-
-struct hb_font_t;
-struct hb_draw_funcs_t;
-
-class HBRenderFont : public rive::RenderFont
-{
-    hb_draw_funcs_t* m_DrawFuncs;
-
-public:
-    hb_font_t* m_Font;
-
-    // We assume ownership of font!
-    HBRenderFont(hb_font_t* font);
-    ~HBRenderFont() override;
-
-    std::vector<Axis> getAxes() const override;
-    std::vector<Coord> getCoords() const override;
-    rive::rcp<rive::RenderFont> makeAtCoords(rive::Span<const Coord>) const override;
-    rive::RawPath getPath(rive::GlyphID) const override;
-    rive::SimpleArray<rive::RenderGlyphRun>
-        onShapeText(rive::Span<const rive::Unichar>,
-                    rive::Span<const rive::RenderTextRun>) const override;
-
-    static rive::rcp<rive::RenderFont> Decode(rive::Span<const uint8_t>);
-
-    // If the platform can supply fallback font(s), set this function pointer.
-    // It will be called with a span of unichars, and the platform attempts to
-    // return a font that can draw (at least some of) them. If no font is available
-    // just return nullptr.
-
-    using FallbackProc = rive::rcp<rive::RenderFont> (*)(rive::Span<const rive::Unichar>);
-
-    static FallbackProc gFallbackProc;
-};
-
-#endif
diff --git a/include/utils/rive_utf.hpp b/include/utils/rive_utf.hpp
index 780292f..e5a79aa 100644
--- a/include/utils/rive_utf.hpp
+++ b/include/utils/rive_utf.hpp
@@ -5,7 +5,7 @@
 #ifndef _RIVE_UTF_HPP_
 #define _RIVE_UTF_HPP_
 
-#include "rive/render_text.hpp"
+#include "rive/text.hpp"
 
 namespace rive
 {
diff --git a/skia/renderer/build.sh b/skia/renderer/build.sh
index 5e51dae..4683ea1 100755
--- a/skia/renderer/build.sh
+++ b/skia/renderer/build.sh
@@ -4,12 +4,6 @@
 export SKIA_DIR="skia"
 source ../../dependencies/config_directories.sh
 
-if [[ ! -d "$DEPENDENCIES/harfbuzz" ]]; then
-    pushd $DEPENDENCIES_SCRIPTS
-    ./get_harfbuzz.sh
-    popd
-fi
-
 # build main rive
 cd ../..
 ./build.sh "$@"
@@ -48,7 +42,7 @@
 else
     build() {
         echo "Building Rive Renderer for platform=$platform option=$OPTION"
-        PREMAKE="premake5 gmake2 $1"
+        PREMAKE="premake5 --scripts=../../../build gmake2 $1"
         eval "$PREMAKE"
         if [ "$OPTION" = "clean" ]; then
             make clean
diff --git a/skia/renderer/include/renderfont_coretext.hpp b/skia/renderer/include/renderfont_coretext.hpp
deleted file mode 100644
index de13daf..0000000
--- a/skia/renderer/include/renderfont_coretext.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#ifndef _RIVE_RENDERFONT_CORETEXT_HPP_
-#define _RIVE_RENDERFONT_CORETEXT_HPP_
-
-#include "rive/factory.hpp"
-#include "rive/render_text.hpp"
-
-#if defined(RIVE_BUILD_FOR_OSX)
-#include <ApplicationServices/ApplicationServices.h>
-#elif defined(RIVE_BUILD_FOR_IOS)
-#include <CoreText/CoreText.h>
-#endif
-
-class CoreTextRenderFont : public rive::RenderFont
-{
-public:
-    CTFontRef m_font;
-    const std::vector<Axis> m_axes;
-    const std::vector<Coord> m_coords;
-
-    // We assume ownership of font!
-    CoreTextRenderFont(CTFontRef, std::vector<Axis>);
-    ~CoreTextRenderFont() override;
-
-    std::vector<Axis> getAxes() const override { return m_axes; }
-    std::vector<Coord> getCoords() const override { return m_coords; }
-    rive::rcp<rive::RenderFont> makeAtCoords(rive::Span<const Coord>) const override;
-    rive::RawPath getPath(rive::GlyphID) const override;
-    rive::SimpleArray<rive::RenderGlyphRun>
-        onShapeText(rive::Span<const rive::Unichar>,
-                    rive::Span<const rive::RenderTextRun>) const override;
-
-    static rive::rcp<rive::RenderFont> Decode(rive::Span<const uint8_t>);
-    static rive::rcp<rive::RenderFont> FromCT(CTFontRef);
-};
-
-#endif
diff --git a/skia/renderer/src/renderfont_coretext.cpp b/skia/renderer/src/renderfont_coretext.cpp
deleted file mode 100644
index 36771da..0000000
--- a/skia/renderer/src/renderfont_coretext.cpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#include "rive/rive_types.hpp"
-#include "utils/rive_utf.hpp"
-
-#if defined(RIVE_BUILD_FOR_APPLE) && defined(WITH_RIVE_TEXT)
-#include "renderfont_coretext.hpp"
-#include "mac_utils.hpp"
-
-#include "rive/factory.hpp"
-#include "rive/render_text.hpp"
-#include "rive/core/type_conversions.hpp"
-
-#if defined(RIVE_BUILD_FOR_OSX)
-#include <ApplicationServices/ApplicationServices.h>
-#elif defined(RIVE_BUILD_FOR_IOS)
-#include <CoreText/CoreText.h>
-#include <CoreText/CTFontManager.h>
-#include <CoreGraphics/CoreGraphics.h>
-#include <CoreFoundation/CoreFoundation.h>
-#endif
-
-constexpr int kStdScale = 2048;
-constexpr float gInvScale = 1.0f / kStdScale;
-
-static std::vector<rive::RenderFont::Axis> compute_axes(CTFontRef font)
-{
-    std::vector<rive::RenderFont::Axis> axes;
-
-    AutoCF array = CTFontCopyVariationAxes(font);
-    if (auto count = array.get() ? CFArrayGetCount(array.get()) : 0)
-    {
-        axes.reserve(count);
-
-        for (auto i = 0; i < count; ++i)
-        {
-            auto axis = (CFDictionaryRef)CFArrayGetValueAtIndex(array, i);
-
-            auto tag = find_u32(axis, kCTFontVariationAxisIdentifierKey);
-            auto min = find_float(axis, kCTFontVariationAxisMinimumValueKey);
-            auto def = find_float(axis, kCTFontVariationAxisDefaultValueKey);
-            auto max = find_float(axis, kCTFontVariationAxisMaximumValueKey);
-            //     printf("%08X %g %g %g\n", tag, min, def, max);
-
-            axes.push_back({tag, min, def, max});
-        }
-    }
-    return axes;
-}
-
-static std::vector<rive::RenderFont::Coord> compute_coords(CTFontRef font)
-{
-    std::vector<rive::RenderFont::Coord> coords(0);
-    AutoCF dict = CTFontCopyVariation(font);
-    if (dict)
-    {
-        int count = CFDictionaryGetCount(dict);
-        if (count > 0)
-        {
-            coords.resize(count);
-
-            AutoSTArray<100, const void*> ptrs(count * 2);
-            const void** keys = &ptrs[0];
-            const void** values = &ptrs[count];
-            CFDictionaryGetKeysAndValues(dict, keys, values);
-            for (int i = 0; i < count; ++i)
-            {
-                uint32_t tag = number_as_u32((CFNumberRef)keys[i]);
-                float value = number_as_float((CFNumberRef)values[i]);
-                //                printf("[%d] %08X %s %g\n", i, tag, tag2str(tag).c_str(), value);
-                coords[i] = {tag, value};
-            }
-        }
-    }
-    return coords;
-}
-
-static rive::RenderFont::LineMetrics make_lmx(CTFontRef font)
-{
-    return {
-        (float)-CTFontGetAscent(font) * gInvScale,
-        (float)CTFontGetDescent(font) * gInvScale,
-    };
-}
-
-CoreTextRenderFont::CoreTextRenderFont(CTFontRef font, std::vector<rive::RenderFont::Axis> axes) :
-    rive::RenderFont(make_lmx(font)),
-    m_font(font), // we take ownership of font
-    m_axes(std::move(axes)),
-    m_coords(compute_coords(font))
-{}
-
-CoreTextRenderFont::~CoreTextRenderFont() { CFRelease(m_font); }
-
-rive::rcp<rive::RenderFont> CoreTextRenderFont::makeAtCoords(rive::Span<const Coord> coords) const
-{
-    AutoCF vars = CFDictionaryCreateMutable(kCFAllocatorDefault,
-                                            coords.size(),
-                                            &kCFTypeDictionaryKeyCallBacks,
-                                            &kCFTypeDictionaryValueCallBacks);
-    for (const auto& c : coords)
-    {
-        AutoCF tagNum = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &c.axis);
-        AutoCF valueNum = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloat32Type, &c.value);
-        CFDictionaryAddValue(vars.get(), tagNum.get(), valueNum.get());
-    }
-
-    AutoCF attrs = CFDictionaryCreateMutable(kCFAllocatorDefault,
-                                             1,
-                                             &kCFTypeDictionaryKeyCallBacks,
-                                             &kCFTypeDictionaryValueCallBacks);
-    CFDictionarySetValue(attrs.get(), kCTFontVariationAttribute, vars.get());
-
-    AutoCF desc = (CTFontDescriptorRef)CTFontDescriptorCreateWithAttributes(attrs.get());
-
-    auto font = CTFontCreateCopyWithAttributes(m_font, 0, nullptr, desc.get());
-
-    return rive::rcp<rive::RenderFont>(new CoreTextRenderFont(font, compute_axes(font)));
-}
-
-static CTFontRef font_from_run(CTRunRef run)
-{
-    auto attr = CTRunGetAttributes(run);
-    assert(attr);
-    CTFontRef ct = (CTFontRef)CFDictionaryGetValue(attr, kCTFontAttributeName);
-    assert(ct);
-    return ct;
-}
-
-static rive::rcp<rive::RenderFont> convert_to_renderfont(CTFontRef ct,
-                                                         rive::rcp<rive::RenderFont> rf)
-{
-    auto ctrf = static_cast<CoreTextRenderFont*>(rf.get());
-    if (ctrf->m_font == ct)
-    {
-        return rf;
-    }
-    CFRetain(ct);
-    return rive::rcp<rive::RenderFont>(new CoreTextRenderFont(ct, compute_axes(ct)));
-}
-
-static void apply_element(void* ctx, const CGPathElement* element)
-{
-    auto path = (rive::RawPath*)ctx;
-    const CGPoint* points = element->points;
-
-    switch (element->type)
-    {
-        case kCGPathElementMoveToPoint:
-            path->moveTo(points[0].x, points[0].y);
-            break;
-
-        case kCGPathElementAddLineToPoint:
-            path->lineTo(points[0].x, points[0].y);
-            break;
-
-        case kCGPathElementAddQuadCurveToPoint:
-            path->quadTo(points[0].x, points[0].y, points[1].x, points[1].y);
-            break;
-
-        case kCGPathElementAddCurveToPoint:
-            path->cubicTo(points[0].x,
-                          points[0].y,
-                          points[1].x,
-                          points[1].y,
-                          points[2].x,
-                          points[2].y);
-            break;
-
-        case kCGPathElementCloseSubpath:
-            path->close();
-            break;
-
-        default:
-            assert(false);
-            break;
-    }
-}
-
-rive::RawPath CoreTextRenderFont::getPath(rive::GlyphID glyph) const
-{
-    rive::RawPath rpath;
-
-    AutoCF cgPath = CTFontCreatePathForGlyph(m_font, glyph, nullptr);
-    if (!cgPath)
-    {
-        return rpath;
-    }
-
-    CGPathApply(cgPath.get(), &rpath, apply_element);
-    rpath.transformInPlace(rive::Mat2D::fromScale(gInvScale, -gInvScale));
-    return rpath;
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-
-struct AutoUTF16
-{
-    std::vector<uint16_t> array;
-
-    AutoUTF16(const rive::Unichar uni[], int count)
-    {
-        array.reserve(count);
-        for (int i = 0; i < count; ++i)
-        {
-            uint16_t tmp[2];
-            int n = rive::UTF::ToUTF16(uni[i], tmp);
-
-            for (int i = 0; i < n; ++i)
-            {
-                array.push_back(tmp[i]);
-            }
-        }
-    }
-};
-
-static rive::RenderGlyphRun add_run(CTRunRef run, uint32_t textStart, float textSize, float& startX)
-{
-    if (auto count = CTRunGetGlyphCount(run))
-    {
-        const float scale = textSize * gInvScale;
-
-        rive::RenderGlyphRun gr(count);
-        gr.size = textSize;
-
-        CTRunGetGlyphs(run, {0, count}, gr.glyphs.data());
-
-        AutoSTArray<1024, CFIndex> indices(count);
-        AutoSTArray<1024, CGSize> advances(count);
-
-        CTRunGetAdvances(run, {0, count}, advances.data());
-        CTRunGetStringIndices(run, {0, count}, indices.data());
-
-        for (CFIndex i = 0; i < count; ++i)
-        {
-            gr.xpos[i] = startX;
-            gr.textIndices[i] = textStart + indices[i]; // utf16 offsets, will fix-up later
-            startX += advances[i].width * scale;
-        }
-        gr.xpos[count] = startX;
-        return gr;
-    }
-    return rive::RenderGlyphRun();
-}
-
-rive::SimpleArray<rive::RenderGlyphRun>
-CoreTextRenderFont::onShapeText(rive::Span<const rive::Unichar> text,
-                                rive::Span<const rive::RenderTextRun> truns) const
-{
-    rive::SimpleArrayBuilder<rive::RenderGlyphRun> gruns(truns.size());
-
-    uint32_t textIndex = 0;
-    float startX = 0;
-    for (const auto& tr : truns)
-    {
-        CTFontRef font = ((CoreTextRenderFont*)tr.font.get())->m_font;
-
-        AutoUTF16 utf16(&text[textIndex], tr.unicharCount);
-        const bool hasSurrogates = utf16.array.size() != tr.unicharCount;
-        assert(!hasSurrogates);
-
-        AutoCF string = CFStringCreateWithCharactersNoCopy(nullptr,
-                                                           utf16.array.data(),
-                                                           utf16.array.size(),
-                                                           kCFAllocatorNull);
-
-        AutoCF attr = CFDictionaryCreateMutable(kCFAllocatorDefault,
-                                                0,
-                                                &kCFTypeDictionaryKeyCallBacks,
-                                                &kCFTypeDictionaryValueCallBacks);
-        CFDictionaryAddValue(attr.get(), kCTFontAttributeName, font);
-
-        AutoCF attrString = CFAttributedStringCreate(kCFAllocatorDefault, string.get(), attr.get());
-
-        AutoCF typesetter = CTTypesetterCreateWithAttributedString(attrString.get());
-
-        AutoCF line = CTTypesetterCreateLine(typesetter.get(), {0, tr.unicharCount});
-
-        CFArrayRef run_array = CTLineGetGlyphRuns(line.get());
-        CFIndex runCount = CFArrayGetCount(run_array);
-        for (CFIndex i = 0; i < runCount; ++i)
-        {
-            CTRunRef runref = (CTRunRef)CFArrayGetValueAtIndex(run_array, i);
-            rive::RenderGlyphRun grun = add_run(runref, textIndex, tr.size, startX);
-            if (grun.glyphs.size() > 0)
-            {
-                auto ct = font_from_run(runref);
-                grun.font = convert_to_renderfont(ct, tr.font);
-                grun.size = tr.size;
-                gruns.add(std::move(grun));
-            }
-        }
-        textIndex += tr.unicharCount;
-    }
-
-    return std::move(gruns);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-rive::rcp<rive::RenderFont> CoreTextRenderFont::FromCT(CTFontRef ctfont)
-{
-    if (!ctfont)
-    {
-        return nullptr;
-    }
-
-    // We always want the ctfont at our magic size
-    if (CTFontGetSize(ctfont) != kStdScale)
-    {
-        ctfont = CTFontCreateCopyWithAttributes(ctfont, kStdScale, nullptr, nullptr);
-    }
-    else
-    {
-        CFRetain(ctfont);
-    }
-
-    // Apple may have secretly set the opsz axis based on the size. We want to undo this
-    // since our stdsize isn't really the size we'll show it at.
-    auto axes = compute_axes(ctfont);
-    if (axes.size() > 0)
-    {
-        constexpr uint32_t kOPSZ = make_tag('o', 'p', 's', 'z');
-        for (const auto& ax : axes)
-        {
-            if (ax.tag == kOPSZ)
-            {
-                auto xform = CGAffineTransformMakeScale(kStdScale / ax.def, kStdScale / ax.def);
-                // Recreate the font at this size, but with a balancing transform,
-                // so we get the 'default' shapes w.r.t. the opsz axis
-                auto newfont = CTFontCreateCopyWithAttributes(ctfont, ax.def, &xform, nullptr);
-                CFRelease(ctfont);
-                ctfont = newfont;
-                break;
-            }
-        }
-    }
-
-    return rive::rcp<rive::RenderFont>(new CoreTextRenderFont(ctfont, std::move(axes)));
-}
-
-rive::rcp<rive::RenderFont> CoreTextRenderFont::Decode(rive::Span<const uint8_t> span)
-{
-    AutoCF data = CFDataCreate(nullptr, span.data(), span.size()); // makes a copy
-    if (!data)
-    {
-        assert(false);
-        return nullptr;
-    }
-
-    AutoCF desc = CTFontManagerCreateFontDescriptorFromData(data.get());
-    if (!desc)
-    {
-        assert(false);
-        return nullptr;
-    }
-
-    CTFontOptions options = kCTFontOptionsPreventAutoActivation;
-
-    AutoCF ctfont =
-        CTFontCreateWithFontDescriptorAndOptions(desc.get(), kStdScale, nullptr, options);
-    if (!ctfont)
-    {
-        assert(false);
-        return nullptr;
-    }
-    return FromCT(ctfont.get());
-}
-
-#endif
diff --git a/src/renderer.cpp b/src/renderer.cpp
index ebcabb1..5447c66 100644
--- a/src/renderer.cpp
+++ b/src/renderer.cpp
@@ -99,17 +99,15 @@
 RenderPath::RenderPath() { Counter::update(Counter::kPath, 1); }
 RenderPath::~RenderPath() { Counter::update(Counter::kPath, -1); }
 
-#include "rive/render_text.hpp"
+#include "rive/text.hpp"
 
-static bool isWhiteSpace(rive::Unichar c) { return c <= ' '; }
+static bool isWhiteSpace(Unichar c) { return c <= ' ' || c == 0x2028; }
 
-rive::SimpleArray<RenderGlyphRun>
-RenderFont::shapeText(rive::Span<const rive::Unichar> text,
-                      rive::Span<const rive::RenderTextRun> runs) const
+SimpleArray<Paragraph> Font::shapeText(Span<const Unichar> text, Span<const TextRun> runs) const
 {
 #ifdef DEBUG
     size_t count = 0;
-    for (const auto& tr : runs)
+    for (const TextRun& tr : runs)
     {
         assert(tr.unicharCount > 0);
         count += tr.unicharCount;
@@ -117,39 +115,40 @@
     assert(count <= text.size());
 #endif
 
-    auto gruns = onShapeText(text, runs);
+    SimpleArray<Paragraph> paragraphs = onShapeText(text, runs);
     bool wantWhiteSpace = false;
-
-    rive::RenderGlyphRun* lastRun = nullptr;
+    GlyphRun* lastRun = nullptr;
     size_t reserveSize = text.size() / 4;
-    rive::SimpleArrayBuilder<uint32_t> breakBuilder(reserveSize);
-    for (auto& gr : gruns)
+    SimpleArrayBuilder<uint32_t> breakBuilder(reserveSize);
+    for (const Paragraph& para : paragraphs)
     {
-        if (lastRun != nullptr)
+        for (GlyphRun& gr : para.runs)
         {
-            lastRun->breaks = std::move(breakBuilder);
-            // Reset the builder.
-            breakBuilder = rive::SimpleArrayBuilder<uint32_t>(reserveSize);
-        }
-        uint32_t glyphIndex = 0;
-        for (auto offset : gr.textIndices)
-        {
-
-            auto unicode = text[offset];
-            if (unicode == '\n')
+            if (lastRun != nullptr)
             {
-                breakBuilder.add(glyphIndex);
-                breakBuilder.add(glyphIndex);
+                lastRun->breaks = std::move(breakBuilder);
+                // Reset the builder.
+                breakBuilder = SimpleArrayBuilder<uint32_t>(reserveSize);
             }
-            if (wantWhiteSpace == isWhiteSpace(unicode))
+            uint32_t glyphIndex = 0;
+            for (uint32_t offset : gr.textIndices)
             {
-                breakBuilder.add(glyphIndex);
-                wantWhiteSpace = !wantWhiteSpace;
+                Unichar unicode = text[offset];
+                if (unicode == '\n' || unicode == 0x2028)
+                {
+                    breakBuilder.add(glyphIndex);
+                    breakBuilder.add(glyphIndex);
+                }
+                if (wantWhiteSpace == isWhiteSpace(unicode))
+                {
+                    breakBuilder.add(glyphIndex);
+                    wantWhiteSpace = !wantWhiteSpace;
+                }
+                glyphIndex++;
             }
-            glyphIndex++;
-        }
 
-        lastRun = &gr;
+            lastRun = &gr;
+        }
     }
     if (lastRun != nullptr)
     {
@@ -161,12 +160,15 @@
     }
 
 #ifdef DEBUG
-    for (const auto& gr : gruns)
+    for (const Paragraph& para : paragraphs)
     {
-        assert(gr.glyphs.size() > 0);
-        assert(gr.glyphs.size() == gr.textIndices.size());
-        assert(gr.glyphs.size() + 1 == gr.xpos.size());
+        for (const GlyphRun& gr : para.runs)
+        {
+            assert(gr.glyphs.size() > 0);
+            assert(gr.glyphs.size() == gr.textIndices.size());
+            assert(gr.glyphs.size() + 1 == gr.xpos.size());
+        }
     }
 #endif
-    return gruns;
+    return paragraphs;
 }
diff --git a/src/text/font_hb.cpp b/src/text/font_hb.cpp
new file mode 100644
index 0000000..d1bea79
--- /dev/null
+++ b/src/text/font_hb.cpp
@@ -0,0 +1,465 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#include "rive/text.hpp"
+
+#ifdef WITH_RIVE_TEXT
+#include "rive/text/font_hb.hpp"
+
+#include "rive/factory.hpp"
+#include "rive/renderer_utils.hpp"
+
+#include "hb.h"
+#include "hb-ot.h"
+extern "C"
+{
+#include "SheenBidi.h"
+}
+
+// Initialized to null. Client can set this to a callback.
+HBFont::FallbackProc HBFont::gFallbackProc;
+
+rive::rcp<rive::Font> HBFont::Decode(rive::Span<const uint8_t> span)
+{
+    auto blob = hb_blob_create_or_fail((const char*)span.data(),
+                                       (unsigned)span.size(),
+                                       HB_MEMORY_MODE_DUPLICATE,
+                                       nullptr,
+                                       nullptr);
+    if (blob)
+    {
+        auto face = hb_face_create(blob, 0);
+        hb_blob_destroy(blob);
+        if (face)
+        {
+            auto font = hb_font_create(face);
+            hb_face_destroy(face);
+            if (font)
+            {
+                return rive::rcp<rive::Font>(new HBFont(font));
+            }
+        }
+    }
+    return nullptr;
+}
+
+//////////////
+
+constexpr int kStdScale = 2048;
+constexpr float gInvScale = 1.0f / kStdScale;
+
+extern "C"
+{
+    static void
+    rpath_move_to(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, float x, float y, void*)
+    {
+        ((rive::RawPath*)rpath)->moveTo(x * gInvScale, -y * gInvScale);
+    }
+    static void
+    rpath_line_to(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, float x1, float y1, void*)
+    {
+        ((rive::RawPath*)rpath)->lineTo(x1 * gInvScale, -y1 * gInvScale);
+    }
+    static void rpath_quad_to(hb_draw_funcs_t*,
+                              void* rpath,
+                              hb_draw_state_t*,
+                              float x1,
+                              float y1,
+                              float x2,
+                              float y2,
+                              void*)
+    {
+        ((rive::RawPath*)rpath)
+            ->quadTo(x1 * gInvScale, -y1 * gInvScale, x2 * gInvScale, -y2 * gInvScale);
+    }
+    static void rpath_cubic_to(hb_draw_funcs_t*,
+                               void* rpath,
+                               hb_draw_state_t*,
+                               float x1,
+                               float y1,
+                               float x2,
+                               float y2,
+                               float x3,
+                               float y3,
+                               void*)
+    {
+        ((rive::RawPath*)rpath)
+            ->cubicTo(x1 * gInvScale,
+                      -y1 * gInvScale,
+                      x2 * gInvScale,
+                      -y2 * gInvScale,
+                      x3 * gInvScale,
+                      -y3 * gInvScale);
+    }
+    static void rpath_close(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, void*)
+    {
+        ((rive::RawPath*)rpath)->close();
+    }
+}
+
+static rive::Font::LineMetrics make_lmx(hb_font_t* font)
+{
+    // premable on font...
+    hb_ot_font_set_funcs(font);
+    hb_font_set_scale(font, kStdScale, kStdScale);
+
+    hb_font_extents_t extents;
+    hb_font_get_h_extents(font, &extents);
+    return {-extents.ascender * gInvScale, -extents.descender * gInvScale};
+}
+
+HBFont::HBFont(hb_font_t* font) :
+    Font(make_lmx(font)), m_Font(font) // we just take ownership, no need to call reference()
+{
+    m_DrawFuncs = hb_draw_funcs_create();
+    hb_draw_funcs_set_move_to_func(m_DrawFuncs, rpath_move_to, nullptr, nullptr);
+    hb_draw_funcs_set_line_to_func(m_DrawFuncs, rpath_line_to, nullptr, nullptr);
+    hb_draw_funcs_set_quadratic_to_func(m_DrawFuncs, rpath_quad_to, nullptr, nullptr);
+    hb_draw_funcs_set_cubic_to_func(m_DrawFuncs, rpath_cubic_to, nullptr, nullptr);
+    hb_draw_funcs_set_close_path_func(m_DrawFuncs, rpath_close, nullptr, nullptr);
+    hb_draw_funcs_make_immutable(m_DrawFuncs);
+}
+
+HBFont::~HBFont()
+{
+    hb_draw_funcs_destroy(m_DrawFuncs);
+    hb_font_destroy(m_Font);
+}
+
+std::vector<rive::Font::Axis> HBFont::getAxes() const
+{
+    auto face = hb_font_get_face(m_Font);
+    std::vector<rive::Font::Axis> axes;
+
+    const int count = hb_ot_var_get_axis_count(face);
+    if (count > 0)
+    {
+        axes.resize(count);
+
+        hb_ot_var_axis_info_t info;
+        for (int i = 0; i < count; ++i)
+        {
+            unsigned n = 1;
+            hb_ot_var_get_axis_infos(face, i, &n, &info);
+            assert(n == 1);
+            axes[i] = {info.tag, info.min_value, info.default_value, info.max_value};
+            //       printf("[%d] %08X %g %g %g\n", i, info.tag, info.min_value, info.default_value,
+            //       info.max_value);
+        }
+    }
+    return axes;
+}
+
+std::vector<rive::Font::Coord> HBFont::getCoords() const
+{
+    auto axes = this->getAxes();
+    //  const int count = (int)axes.size();
+
+    unsigned length;
+    const float* values = hb_font_get_var_coords_design(m_Font, &length);
+
+    std::vector<rive::Font::Coord> coords(length);
+    for (unsigned i = 0; i < length; ++i)
+    {
+        coords[i] = {axes[i].tag, values[i]};
+    }
+    return coords;
+}
+
+rive::rcp<rive::Font> HBFont::makeAtCoords(rive::Span<const Coord> coords) const
+{
+    AutoSTArray<16, hb_variation_t> vars(coords.size());
+    for (size_t i = 0; i < coords.size(); ++i)
+    {
+        vars[i] = {coords[i].axis, coords[i].value};
+    }
+    auto font = hb_font_create_sub_font(m_Font);
+    hb_font_set_variations(font, vars.data(), (unsigned int)vars.size());
+    return rive::rcp<rive::Font>(new HBFont(font));
+}
+
+rive::RawPath HBFont::getPath(rive::GlyphID glyph) const
+{
+    rive::RawPath rpath;
+    hb_font_get_glyph_shape(m_Font, glyph, m_DrawFuncs, &rpath);
+    return rpath;
+}
+
+///////////////////////////////////////////////////////////
+
+const hb_feature_t gFeatures[] = {
+    {'liga', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
+    {'dlig', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
+    // {'clig', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
+    // {'calt', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
+    {'kern', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
+};
+constexpr int gNumFeatures = sizeof(gFeatures) / sizeof(gFeatures[0]);
+
+static rive::GlyphRun shape_run(const rive::Unichar text[],
+                                const rive::TextRun& tr,
+                                unsigned textOffset)
+{
+    hb_buffer_t* buf = hb_buffer_create();
+    hb_buffer_add_utf32(buf, text, tr.unicharCount, 0, tr.unicharCount);
+
+    hb_buffer_set_direction(buf,
+                            tr.dir == rive::TextDirection::rtl ? HB_DIRECTION_RTL
+                                                               : HB_DIRECTION_LTR);
+    hb_buffer_set_script(buf, (hb_script_t)tr.script); // HB_SCRIPT_ARABIC);
+    hb_buffer_set_language(buf, hb_language_from_string("fa", -1));
+
+    auto hbfont = (HBFont*)tr.font.get();
+    hb_shape(hbfont->m_Font, buf, gFeatures, gNumFeatures);
+
+    unsigned int glyph_count;
+    hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
+    hb_glyph_position_t* glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
+
+    // todo: check for missing glyphs, and perform font-substitution
+
+    rive::GlyphRun gr(glyph_count);
+    gr.font = tr.font;
+    gr.size = tr.size;
+    gr.styleId = tr.styleId;
+    gr.dir = tr.dir;
+
+    const float scale = tr.size / kStdScale;
+    for (unsigned int i = 0; i < glyph_count; i++)
+    {
+        //            hb_position_t x_offset  = glyph_pos[i].x_offset;
+        //            hb_position_t y_offset  = glyph_pos[i].y_offset;
+        unsigned int index = tr.dir == rive::TextDirection::rtl ? glyph_count - 1 - i : i;
+        gr.glyphs[i] = (uint16_t)glyph_info[index].codepoint;
+        gr.textIndices[i] = textOffset + glyph_info[index].cluster;
+        gr.advances[i] = gr.xpos[i] = glyph_pos[index].x_advance * scale;
+    }
+    gr.xpos[glyph_count] = 0; // so the next run can line up snug
+    hb_buffer_destroy(buf);
+    return gr;
+}
+
+static rive::GlyphRun extract_subset(const rive::GlyphRun& orig, size_t start, size_t end)
+{
+    auto count = end - start;
+    rive::GlyphRun subset(rive::SimpleArray<rive::GlyphID>(&orig.glyphs[start], count),
+                          rive::SimpleArray<uint32_t>(&orig.textIndices[start], count),
+                          rive::SimpleArray<float>(&orig.advances[start], count),
+                          rive::SimpleArray<float>(&orig.xpos[start], count));
+    subset.font = std::move(orig.font);
+    subset.size = orig.size;
+    subset.xpos.back() = 0; // since we're now the end of a run
+    subset.styleId = orig.styleId;
+
+    return subset;
+}
+
+static void perform_fallback(rive::rcp<rive::Font> fallbackFont,
+                             rive::SimpleArrayBuilder<rive::GlyphRun>& gruns,
+                             const rive::Unichar text[],
+                             const rive::GlyphRun& orig,
+                             const rive::TextRun& origTextRun)
+{
+    assert(orig.glyphs.size() > 0);
+
+    const size_t count = orig.glyphs.size();
+    size_t startI = 0;
+    while (startI < count)
+    {
+        size_t endI = startI + 1;
+        if (orig.glyphs[startI] == 0)
+        {
+            while (endI < count && orig.glyphs[endI] == 0)
+            {
+                ++endI;
+            }
+            auto textStart = orig.textIndices[startI];
+            auto textCount = orig.textIndices[endI - 1] - textStart + 1;
+            auto tr = rive::TextRun{
+                fallbackFont,
+                orig.size,
+                textCount,
+                origTextRun.script,
+                orig.styleId,
+                orig.dir,
+            };
+            gruns.add(shape_run(&text[textStart], tr, textStart));
+        }
+        else
+        {
+            while (endI < count && orig.glyphs[endI] != 0)
+            {
+                ++endI;
+            }
+            gruns.add(extract_subset(orig, startI, endI));
+        }
+        startI = endI;
+    }
+}
+
+rive::SimpleArray<rive::Paragraph> HBFont::onShapeText(rive::Span<const rive::Unichar> text,
+                                                       rive::Span<const rive::TextRun> truns) const
+{
+
+    rive::SimpleArrayBuilder<rive::Paragraph> paragraphs;
+    SBCodepointSequence codepointSequence = {SBStringEncodingUTF32,
+                                             (void*)text.data(),
+                                             text.size()};
+
+    hb_unicode_funcs_t* ufuncs = hb_unicode_funcs_get_default();
+
+    // Split runs by bidi types.
+    uint32_t textIndex = 0;
+    uint32_t runIndex = 0;
+    uint32_t runStartTextIndex = 0;
+
+    SBUInteger paragraphStart = 0;
+
+    SBAlgorithmRef bidiAlgorithm = SBAlgorithmCreate(&codepointSequence);
+    uint32_t unicharIndex = 0;
+    uint32_t runTextIndex = 0;
+
+    while (paragraphStart < text.size())
+    {
+        SBParagraphRef paragraph =
+            SBAlgorithmCreateParagraph(bidiAlgorithm, paragraphStart, INT32_MAX, SBLevelDefaultLTR);
+        SBUInteger paragraphLength = SBParagraphGetLength(paragraph);
+        // Next iteration reads the next paragraph (if any remain).
+        paragraphStart += paragraphLength;
+        const SBLevel* bidiLevels = SBParagraphGetLevelsPtr(paragraph);
+        SBLevel paragraphLevel = SBParagraphGetBaseLevel(paragraph);
+        uint32_t paragraphTextIndex = 0;
+
+        std::vector<rive::TextRun> bidiRuns;
+        bidiRuns.reserve(truns.size());
+
+        while (runIndex < truns.size())
+        {
+            const auto& tr = truns[runIndex];
+            assert(tr.unicharCount != 0);
+            SBLevel lastLevel = bidiLevels[paragraphTextIndex];
+            hb_script_t lastScript = hb_unicode_script(ufuncs, text[textIndex]);
+            rive::TextRun splitRun = {
+                .font = tr.font,
+                .size = tr.size,
+                .unicharCount = tr.unicharCount - runTextIndex,
+                .script = (uint32_t)lastScript,
+                .styleId = tr.styleId,
+                .dir = lastLevel & 1 ? rive::TextDirection::rtl : rive::TextDirection::ltr,
+            };
+
+            runStartTextIndex = textIndex;
+
+            runTextIndex++;
+            textIndex++;
+            paragraphTextIndex++;
+            bidiRuns.push_back(splitRun);
+
+            while (runTextIndex < tr.unicharCount && paragraphTextIndex < paragraphLength)
+            {
+                hb_script_t script = hb_unicode_script(ufuncs, text[textIndex]);
+                switch (script)
+                {
+                    case HB_SCRIPT_COMMON:
+                    case HB_SCRIPT_INHERITED:
+                        // Propagate last seen "real" script value.
+                        script = lastScript;
+                        break;
+                    default:
+                        break;
+                }
+                if (bidiLevels[paragraphTextIndex] != lastLevel || script != lastScript)
+                {
+                    lastScript = script;
+                    auto& back = bidiRuns.back();
+                    back.unicharCount = textIndex - runStartTextIndex;
+                    lastLevel = bidiLevels[paragraphTextIndex];
+
+                    rive::TextRun splitRun = {
+                        .font = back.font,
+                        .size = back.size,
+                        .unicharCount = tr.unicharCount - runTextIndex,
+                        .script = (uint32_t)script,
+                        .styleId = back.styleId,
+                        .dir = lastLevel & 1 ? rive::TextDirection::rtl : rive::TextDirection::ltr,
+                    };
+                    runStartTextIndex = textIndex;
+                    bidiRuns.push_back(splitRun);
+                }
+                runTextIndex++;
+                textIndex++;
+                paragraphTextIndex++;
+            }
+            // Reached the end of the run?
+            if (runTextIndex == tr.unicharCount)
+            {
+                runIndex++;
+                runTextIndex = 0;
+            }
+            // We consumed the whole paragraph.
+            if (paragraphTextIndex == paragraphLength)
+            {
+                // Close off the last run.
+                auto& back = bidiRuns.back();
+                back.unicharCount = textIndex - runStartTextIndex;
+                break;
+            }
+        }
+
+        rive::SimpleArrayBuilder<rive::GlyphRun> gruns(bidiRuns.size());
+
+        for (const auto& tr : bidiRuns)
+        {
+            auto gr = shape_run(&text[unicharIndex], tr, unicharIndex);
+            unicharIndex += tr.unicharCount;
+
+            auto end = gr.glyphs.end();
+            auto iter = std::find(gr.glyphs.begin(), end, 0);
+            if (!gFallbackProc || iter == end)
+            {
+                gruns.add(std::move(gr));
+            }
+            else
+            {
+                // found at least 1 zero in glyphs, so need to perform font-fallback
+                size_t index = iter - gr.glyphs.begin();
+                rive::Unichar missing = text[gr.textIndices[index]];
+                // todo: consider sending more chars if that helps choose a font
+                auto fallback = gFallbackProc({&missing, 1});
+                if (fallback)
+                {
+                    perform_fallback(fallback, gruns, text.data(), gr, tr);
+                }
+                else
+                {
+                    gruns.add(std::move(gr)); // oh well, just keep the missing glyphs
+                }
+            }
+        }
+
+        // turn the advances we stored in xpos[] into actual x-positions
+        // for logical order.
+        float pos = 0;
+        for (auto& gr : gruns)
+        {
+            for (auto& xp : gr.xpos)
+            {
+                float adv = xp;
+                xp = pos;
+                pos += adv;
+            }
+        }
+
+        paragraphs.add({
+            std::move(gruns),
+            paragraphLevel & 1 ? rive::TextDirection::rtl : rive::TextDirection::ltr,
+        });
+        SBParagraphRelease(paragraph);
+    }
+
+    SBAlgorithmRelease(bidiAlgorithm);
+    return paragraphs;
+}
+
+#endif
\ No newline at end of file
diff --git a/src/text/line_breaker.cpp b/src/text/line_breaker.cpp
index 190cac0..996d6dd 100644
--- a/src/text/line_breaker.cpp
+++ b/src/text/line_breaker.cpp
@@ -2,40 +2,36 @@
  * Copyright 2022 Rive
  */
 
-#include "rive/text/line_breaker.hpp"
+#include "rive/text.hpp"
 #include <limits>
+#include <algorithm>
 using namespace rive;
 
 static bool autowidth(float width) { return width < 0.0f; }
-void RenderGlyphLine::ComputeLineSpacing(Span<RenderGlyphLine> lines,
-                                         Span<const RenderGlyphRun> runs,
-                                         float width,
-                                         RenderTextAlign align)
-{
 
+float GlyphLine::ComputeMaxWidth(Span<GlyphLine> lines, Span<const GlyphRun> runs)
+{
     float maxLineWidth = 0.0f;
-    if (autowidth(width))
+    for (auto& line : lines)
     {
-        for (auto& line : lines)
-        {
-            auto lineWidth =
-                runs[line.endRun].xpos[line.endIndex] - runs[line.startRun].xpos[line.startIndex];
-            if (lineWidth > maxLineWidth)
-            {
-                maxLineWidth = lineWidth;
-            }
-        }
+        maxLineWidth = std::max(maxLineWidth,
+                                runs[line.endRunIndex].xpos[line.endGlyphIndex] -
+                                    runs[line.startRunIndex].xpos[line.startGlyphIndex]);
     }
-    else
-    {
-        maxLineWidth = width;
-    }
+    return maxLineWidth;
+}
+
+void GlyphLine::ComputeLineSpacing(Span<GlyphLine> lines,
+                                   Span<const GlyphRun> runs,
+                                   float width,
+                                   TextAlign align)
+{
     float Y = 0; // top of our frame
     for (auto& line : lines)
     {
         float asc = 0;
         float des = 0;
-        for (int i = line.startRun; i <= line.endRun; ++i)
+        for (int i = line.startRunIndex; i <= line.endRunIndex; ++i)
         {
             const auto& run = runs[i];
 
@@ -47,18 +43,18 @@
         line.baseline = Y;
         Y += des;
         line.bottom = Y;
-        auto lineWidth =
-            runs[line.endRun].xpos[line.endIndex] - runs[line.startRun].xpos[line.startIndex];
+        auto lineWidth = runs[line.endRunIndex].xpos[line.endGlyphIndex] -
+                         runs[line.startRunIndex].xpos[line.startGlyphIndex];
         switch (align)
         {
-            case RenderTextAlign::right:
-                line.startX = maxLineWidth - lineWidth;
+            case TextAlign::right:
+                line.startX = width - lineWidth;
                 break;
-            case RenderTextAlign::left:
+            case TextAlign::left:
                 line.startX = 0;
                 break;
-            case RenderTextAlign::center:
-                line.startX = maxLineWidth / 2.0f - lineWidth / 2.0f;
+            case TextAlign::center:
+                line.startX = width / 2.0f - lineWidth / 2.0f;
                 break;
         }
     }
@@ -66,15 +62,14 @@
 
 struct WordMarker
 {
-    const RenderGlyphRun* run;
+    const GlyphRun* run;
     uint32_t index;
 
-    bool next(Span<const RenderGlyphRun> runs)
+    bool next(Span<const GlyphRun> runs)
     {
         index += 2;
         while (index >= run->breaks.size())
         {
-
             index -= run->breaks.size();
             run++;
             if (run == runs.end())
@@ -88,12 +83,12 @@
 
 class RunIterator
 {
-    Span<const RenderGlyphRun> m_runs;
-    const RenderGlyphRun* m_run;
+    Span<const GlyphRun> m_runs;
+    const GlyphRun* m_run;
     uint32_t m_index;
 
 public:
-    RunIterator(Span<const RenderGlyphRun> runs, const RenderGlyphRun* run, uint32_t index) :
+    RunIterator(Span<const GlyphRun> runs, const GlyphRun* run, uint32_t index) :
         m_runs(runs), m_run(run), m_index(index)
     {}
 
@@ -147,20 +142,17 @@
 
     float x() const { return m_run->xpos[m_index]; }
 
-    const RenderGlyphRun* run() const { return m_run; }
+    const GlyphRun* run() const { return m_run; }
     uint32_t index() const { return m_index; }
 
     bool operator==(const RunIterator& o) const { return m_run == o.m_run && m_index == o.m_index; }
 };
 
-std::vector<RenderGlyphLine> RenderGlyphLine::BreakLines(Span<const RenderGlyphRun> runs,
-                                                         float width,
-                                                         RenderTextAlign align)
+SimpleArray<GlyphLine> GlyphLine::BreakLines(Span<const GlyphRun> runs, float width)
 {
-
     float maxLineWidth = autowidth(width) ? std::numeric_limits<float>::max() : width;
 
-    std::vector<RenderGlyphLine> lines;
+    SimpleArrayBuilder<GlyphLine> lines;
 
     if (runs.empty())
     {
@@ -171,19 +163,26 @@
 
     bool advanceWord = false;
     WordMarker start = {runs.begin(), 0};
-    WordMarker end = {runs.begin(), 1};
+    WordMarker end = {runs.begin(), (uint32_t)-1};
+    if (!end.next(runs))
+    {
+        return lines;
+    }
 
-    RenderGlyphLine line = RenderGlyphLine();
+    GlyphLine line = GlyphLine();
 
     uint32_t breakIndex = end.run->breaks[end.index];
-    uint32_t lastEndIndex = end.index;
+    const GlyphRun* breakRun = end.run;
+    uint32_t lastEndGlyphIndex = end.index;
     uint32_t startBreakIndex = start.run->breaks[start.index];
+    const GlyphRun* startBreakRun = start.run;
+
     float x = end.run->xpos[breakIndex];
     while (true)
     {
         if (advanceWord)
         {
-            lastEndIndex = end.index;
+            lastEndGlyphIndex = end.index;
 
             if (!start.next(runs))
             {
@@ -197,26 +196,29 @@
             advanceWord = false;
 
             breakIndex = end.run->breaks[end.index];
+            breakRun = end.run;
             startBreakIndex = start.run->breaks[start.index];
+            startBreakRun = start.run;
             x = end.run->xpos[breakIndex];
         }
 
-        if (breakIndex != startBreakIndex && x > limit)
+        bool isForcedBreak = breakRun == startBreakRun && breakIndex == startBreakIndex;
+
+        if (!isForcedBreak && x > limit)
         {
-            uint32_t startRun = (uint32_t)(start.run - runs.begin());
+            uint32_t startRunIndex = (uint32_t)(start.run - runs.begin());
 
             // A whole word overflowed, break until we can no longer break (or
             // it fits).
-            if (line.startRun == startRun && line.startIndex == startBreakIndex)
+            if (line.startRunIndex == startRunIndex && line.startGlyphIndex == startBreakIndex)
             {
                 bool canBreakMore = true;
                 while (canBreakMore && x > limit)
                 {
 
                     RunIterator lineStart =
-                        RunIterator(runs, runs.begin() + line.startRun, line.startIndex);
+                        RunIterator(runs, runs.begin() + line.startRunIndex, line.startGlyphIndex);
                     RunIterator lineEnd = RunIterator(runs, end.run, end.run->breaks[end.index]);
-
                     // Look for the next character that doesn't overflow.
                     while (true)
                     {
@@ -237,8 +239,8 @@
                             }
                             else
                             {
-                                line.endRun = (uint32_t)(lineEnd.run() - runs.begin());
-                                line.endIndex = lineEnd.index();
+                                line.endRunIndex = (uint32_t)(lineEnd.run() - runs.begin());
+                                line.endGlyphIndex = lineEnd.index();
                             }
                             break;
                         }
@@ -249,11 +251,10 @@
                         limit = lineEnd.x() + maxLineWidth;
                         if (!line.empty())
                         {
-                            lines.push_back(line);
+                            lines.add(line);
                         }
                         // Setup the next line.
-                        line = RenderGlyphLine((uint32_t)(lineEnd.run() - runs.begin()),
-                                               lineEnd.index());
+                        line = GlyphLine((uint32_t)(lineEnd.run() - runs.begin()), lineEnd.index());
                     }
                 }
             }
@@ -263,35 +264,34 @@
                 auto startX = start.run->xpos[start.run->breaks[start.index]];
                 limit = startX + maxLineWidth;
 
-                if (!line.empty() || start.index - lastEndIndex > 1)
+                if (!line.empty() || start.index - lastEndGlyphIndex > 1)
                 {
-                    lines.push_back(line);
+                    lines.add(line);
                 }
 
-                line = RenderGlyphLine(startRun, startBreakIndex);
+                line = GlyphLine(startRunIndex, startBreakIndex);
             }
         }
         else
         {
-            line.endRun = (uint32_t)(end.run - runs.begin());
-            line.endIndex = end.run->breaks[end.index];
+            line.endRunIndex = (uint32_t)(end.run - runs.begin());
+            line.endGlyphIndex = end.run->breaks[end.index];
             advanceWord = true;
             // Forced BR.
-            if (breakIndex == startBreakIndex)
+            if (isForcedBreak)
             {
-                lines.push_back(line);
-                auto startX = start.run->xpos[start.run->breaks[start.index]];
+                lines.add(line);
+                auto startX = start.run->xpos[start.run->breaks[start.index] + 1];
                 limit = startX + maxLineWidth;
-                line = RenderGlyphLine((uint32_t)(start.run - runs.begin()), startBreakIndex + 1);
+                line = GlyphLine((uint32_t)(start.run - runs.begin()), startBreakIndex + 1);
             }
         }
     }
     // Don't add a line that starts/ends at the same spot.
     if (!line.empty())
     {
-        lines.push_back(line);
+        lines.add(line);
     }
 
-    ComputeLineSpacing(lines, runs, width, align);
     return lines;
 }
\ No newline at end of file
diff --git a/src/text/renderfont_hb.cpp b/src/text/renderfont_hb.cpp
deleted file mode 100644
index 5b536aa..0000000
--- a/src/text/renderfont_hb.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
- * Copyright 2022 Rive
- */
-
-#include "rive/render_text.hpp"
-
-#ifdef WITH_RIVE_TEXT
-#include "rive/text/renderfont_hb.hpp"
-
-#include "rive/factory.hpp"
-#include "rive/renderer_utils.hpp"
-
-#include "hb.h"
-#include "hb-ot.h"
-
-// Initialized to null. Client can set this to a callback.
-HBRenderFont::FallbackProc HBRenderFont::gFallbackProc;
-
-rive::rcp<rive::RenderFont> HBRenderFont::Decode(rive::Span<const uint8_t> span)
-{
-    auto blob = hb_blob_create_or_fail((const char*)span.data(),
-                                       (unsigned)span.size(),
-                                       HB_MEMORY_MODE_DUPLICATE,
-                                       nullptr,
-                                       nullptr);
-    if (blob)
-    {
-        auto face = hb_face_create(blob, 0);
-        hb_blob_destroy(blob);
-        if (face)
-        {
-            auto font = hb_font_create(face);
-            hb_face_destroy(face);
-            if (font)
-            {
-                return rive::rcp<rive::RenderFont>(new HBRenderFont(font));
-            }
-        }
-    }
-    return nullptr;
-}
-
-//////////////
-
-constexpr int kStdScale = 2048;
-constexpr float gInvScale = 1.0f / kStdScale;
-
-extern "C"
-{
-    static void
-    rpath_move_to(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, float x, float y, void*)
-    {
-        ((rive::RawPath*)rpath)->moveTo(x * gInvScale, -y * gInvScale);
-    }
-    static void
-    rpath_line_to(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, float x1, float y1, void*)
-    {
-        ((rive::RawPath*)rpath)->lineTo(x1 * gInvScale, -y1 * gInvScale);
-    }
-    static void rpath_quad_to(hb_draw_funcs_t*,
-                              void* rpath,
-                              hb_draw_state_t*,
-                              float x1,
-                              float y1,
-                              float x2,
-                              float y2,
-                              void*)
-    {
-        ((rive::RawPath*)rpath)
-            ->quadTo(x1 * gInvScale, -y1 * gInvScale, x2 * gInvScale, -y2 * gInvScale);
-    }
-    static void rpath_cubic_to(hb_draw_funcs_t*,
-                               void* rpath,
-                               hb_draw_state_t*,
-                               float x1,
-                               float y1,
-                               float x2,
-                               float y2,
-                               float x3,
-                               float y3,
-                               void*)
-    {
-        ((rive::RawPath*)rpath)
-            ->cubicTo(x1 * gInvScale,
-                      -y1 * gInvScale,
-                      x2 * gInvScale,
-                      -y2 * gInvScale,
-                      x3 * gInvScale,
-                      -y3 * gInvScale);
-    }
-    static void rpath_close(hb_draw_funcs_t*, void* rpath, hb_draw_state_t*, void*)
-    {
-        ((rive::RawPath*)rpath)->close();
-    }
-}
-
-static rive::RenderFont::LineMetrics make_lmx(hb_font_t* font)
-{
-    // premable on font...
-    hb_ot_font_set_funcs(font);
-    hb_font_set_scale(font, kStdScale, kStdScale);
-
-    hb_font_extents_t extents;
-    hb_font_get_h_extents(font, &extents);
-    return {-extents.ascender * gInvScale, -extents.descender * gInvScale};
-}
-
-HBRenderFont::HBRenderFont(hb_font_t* font) :
-    RenderFont(make_lmx(font)), m_Font(font) // we just take ownership, no need to call reference()
-{
-    m_DrawFuncs = hb_draw_funcs_create();
-    hb_draw_funcs_set_move_to_func(m_DrawFuncs, rpath_move_to, nullptr, nullptr);
-    hb_draw_funcs_set_line_to_func(m_DrawFuncs, rpath_line_to, nullptr, nullptr);
-    hb_draw_funcs_set_quadratic_to_func(m_DrawFuncs, rpath_quad_to, nullptr, nullptr);
-    hb_draw_funcs_set_cubic_to_func(m_DrawFuncs, rpath_cubic_to, nullptr, nullptr);
-    hb_draw_funcs_set_close_path_func(m_DrawFuncs, rpath_close, nullptr, nullptr);
-    hb_draw_funcs_make_immutable(m_DrawFuncs);
-}
-
-HBRenderFont::~HBRenderFont()
-{
-    hb_draw_funcs_destroy(m_DrawFuncs);
-    hb_font_destroy(m_Font);
-}
-
-std::vector<rive::RenderFont::Axis> HBRenderFont::getAxes() const
-{
-    auto face = hb_font_get_face(m_Font);
-    std::vector<rive::RenderFont::Axis> axes;
-
-    const int count = hb_ot_var_get_axis_count(face);
-    if (count > 0)
-    {
-        axes.resize(count);
-
-        hb_ot_var_axis_info_t info;
-        for (int i = 0; i < count; ++i)
-        {
-            unsigned n = 1;
-            hb_ot_var_get_axis_infos(face, i, &n, &info);
-            assert(n == 1);
-            axes[i] = {info.tag, info.min_value, info.default_value, info.max_value};
-            //       printf("[%d] %08X %g %g %g\n", i, info.tag, info.min_value, info.default_value,
-            //       info.max_value);
-        }
-    }
-    return axes;
-}
-
-std::vector<rive::RenderFont::Coord> HBRenderFont::getCoords() const
-{
-    auto axes = this->getAxes();
-    //  const int count = (int)axes.size();
-
-    unsigned length;
-    const float* values = hb_font_get_var_coords_design(m_Font, &length);
-
-    std::vector<rive::RenderFont::Coord> coords(length);
-    for (unsigned i = 0; i < length; ++i)
-    {
-        coords[i] = {axes[i].tag, values[i]};
-    }
-    return coords;
-}
-
-rive::rcp<rive::RenderFont> HBRenderFont::makeAtCoords(rive::Span<const Coord> coords) const
-{
-    AutoSTArray<16, hb_variation_t> vars(coords.size());
-    for (size_t i = 0; i < coords.size(); ++i)
-    {
-        vars[i] = {coords[i].axis, coords[i].value};
-    }
-    auto font = hb_font_create_sub_font(m_Font);
-    hb_font_set_variations(font, vars.data(), (unsigned int)vars.size());
-    return rive::rcp<rive::RenderFont>(new HBRenderFont(font));
-}
-
-rive::RawPath HBRenderFont::getPath(rive::GlyphID glyph) const
-{
-    rive::RawPath rpath;
-    hb_font_get_glyph_shape(m_Font, glyph, m_DrawFuncs, &rpath);
-    return rpath;
-}
-
-///////////////////////////////////////////////////////////
-
-const hb_feature_t gFeatures[] = {
-    {'liga', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
-    {'dlig', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
-    {'kern', 1, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END},
-};
-constexpr int gNumFeatures = sizeof(gFeatures) / sizeof(gFeatures[0]);
-
-static rive::RenderGlyphRun shape_run(const rive::Unichar text[],
-                                      const rive::RenderTextRun& tr,
-                                      unsigned textOffset)
-{
-    hb_buffer_t* buf = hb_buffer_create();
-    hb_buffer_add_utf32(buf, text, tr.unicharCount, 0, tr.unicharCount);
-
-    hb_buffer_set_direction(buf, HB_DIRECTION_LTR);
-    hb_buffer_set_script(buf, HB_SCRIPT_LATIN);
-    hb_buffer_set_language(buf, hb_language_from_string("en", -1));
-
-    auto hbfont = (HBRenderFont*)tr.font.get();
-    hb_shape(hbfont->m_Font, buf, gFeatures, gNumFeatures);
-
-    unsigned int glyph_count;
-    hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
-    hb_glyph_position_t* glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
-
-    // todo: check for missing glyphs, and perform font-substitution
-
-    rive::RenderGlyphRun gr(glyph_count);
-    gr.font = tr.font;
-    gr.size = tr.size;
-
-    const float scale = tr.size / kStdScale;
-    for (unsigned int i = 0; i < glyph_count; i++)
-    {
-        //            hb_position_t x_offset  = glyph_pos[i].x_offset;
-        //            hb_position_t y_offset  = glyph_pos[i].y_offset;
-
-        gr.glyphs[i] = (uint16_t)glyph_info[i].codepoint;
-        gr.textIndices[i] = textOffset + glyph_info[i].cluster;
-        gr.xpos[i] = glyph_pos[i].x_advance * scale;
-    }
-    gr.xpos[glyph_count] = 0; // so the next run can line up snug
-    hb_buffer_destroy(buf);
-    return gr;
-}
-
-static rive::RenderGlyphRun extract_subset(const rive::RenderGlyphRun& orig,
-                                           size_t start,
-                                           size_t end)
-{
-    auto count = end - start;
-    rive::RenderGlyphRun subset(rive::SimpleArray<rive::GlyphID>(&orig.glyphs[start], count),
-                                rive::SimpleArray<uint32_t>(&orig.textIndices[start], count),
-                                rive::SimpleArray<float>(&orig.xpos[start], count));
-    subset.font = std::move(orig.font);
-    subset.size = orig.size;
-    subset.xpos.back() = 0; // since we're now the end of a run
-
-    return subset;
-}
-
-static void perform_fallback(rive::rcp<rive::RenderFont> fallbackFont,
-                             rive::SimpleArrayBuilder<rive::RenderGlyphRun>& gruns,
-                             const rive::Unichar text[],
-                             const rive::RenderGlyphRun& orig)
-{
-    assert(orig.glyphs.size() > 0);
-
-    const size_t count = orig.glyphs.size();
-    size_t startI = 0;
-    while (startI < count)
-    {
-        size_t endI = startI + 1;
-        if (orig.glyphs[startI] == 0)
-        {
-            while (endI < count && orig.glyphs[endI] == 0)
-            {
-                ++endI;
-            }
-            auto textStart = orig.textIndices[startI];
-            auto textCount = orig.textIndices[endI - 1] - textStart + 1;
-            auto tr = rive::RenderTextRun{fallbackFont, orig.size, textCount};
-            gruns.add(shape_run(&text[textStart], tr, textStart));
-        }
-        else
-        {
-            while (endI < count && orig.glyphs[endI] != 0)
-            {
-                ++endI;
-            }
-            gruns.add(extract_subset(orig, startI, endI));
-        }
-        startI = endI;
-    }
-}
-
-rive::SimpleArray<rive::RenderGlyphRun>
-HBRenderFont::onShapeText(rive::Span<const rive::Unichar> text,
-                          rive::Span<const rive::RenderTextRun> truns) const
-{
-    rive::SimpleArrayBuilder<rive::RenderGlyphRun> gruns(truns.size());
-
-    /////////////////
-
-    uint32_t unicharIndex = 0;
-    for (const auto& tr : truns)
-    {
-        auto gr = shape_run(&text[unicharIndex], tr, unicharIndex);
-        unicharIndex += tr.unicharCount;
-
-        auto end = gr.glyphs.end();
-        auto iter = std::find(gr.glyphs.begin(), end, 0);
-        if (!gFallbackProc || iter == end)
-        {
-            gruns.add(std::move(gr));
-        }
-        else
-        {
-            // found at least 1 zero in glyphs, so need to perform font-fallback
-            size_t index = iter - gr.glyphs.begin();
-            rive::Unichar missing = text[gr.textIndices[index]];
-            // todo: consider sending more chars if that helps choose a font
-            auto fallback = gFallbackProc({&missing, 1});
-            if (fallback)
-            {
-                perform_fallback(fallback, gruns, text.data(), gr);
-            }
-            else
-            {
-                gruns.add(std::move(gr)); // oh well, just keep the missing glyphs
-            }
-        }
-    }
-
-    // now turn the advances (widths) we stored in xpos[] into actual x-positions
-    float pos = 0;
-    for (auto& gr : gruns)
-    {
-        for (auto& xp : gr.xpos)
-        {
-            float adv = xp;
-            xp = pos;
-            pos += adv;
-        }
-    }
-    return std::move(gruns);
-}
-
-#endif
\ No newline at end of file
diff --git a/tess/build/macosx/build_tess.sh b/tess/build/macosx/build_tess.sh
index 0054e3d..13df959 100755
--- a/tess/build/macosx/build_tess.sh
+++ b/tess/build/macosx/build_tess.sh
@@ -51,7 +51,7 @@
     fi
 done
 
-$PREMAKE --file=./premake5_tess.lua gmake2 --graphics=$GRAPHICS --with_rive_tools
+$PREMAKE --scripts=../../build --file=./premake5_tess.lua gmake2 --graphics=$GRAPHICS --with_rive_tools
 
 for var in "$@"; do
     if [[ $var = "clean" ]]; then
diff --git a/test/assets/IBMPlexSansArabic-Regular.ttf b/test/assets/IBMPlexSansArabic-Regular.ttf
new file mode 100644
index 0000000..da3eba1
--- /dev/null
+++ b/test/assets/IBMPlexSansArabic-Regular.ttf
Binary files differ
diff --git a/test/assets/NotoSansArabic-VariableFont_wdth,wght.ttf b/test/assets/NotoSansArabic-VariableFont_wdth,wght.ttf
new file mode 100644
index 0000000..0356020
--- /dev/null
+++ b/test/assets/NotoSansArabic-VariableFont_wdth,wght.ttf
Binary files differ
diff --git a/test/line_break_test.cpp b/test/line_break_test.cpp
index da18244..ecde0ac 100644
--- a/test/line_break_test.cpp
+++ b/test/line_break_test.cpp
@@ -4,17 +4,16 @@
 
 #include <rive/simple_array.hpp>
 #include <catch.hpp>
-#include <rive/render_text.hpp>
-#include <rive/text/renderfont_hb.hpp>
-#include <rive/text/line_breaker.hpp>
+#include <rive/text.hpp>
+#include <rive/text/font_hb.hpp>
 #include "utils/rive_utf.hpp"
 
 using namespace rive;
 
-static rive::RenderTextRun append(std::vector<rive::Unichar>* unichars,
-                                  rive::rcp<rive::RenderFont> font,
-                                  float size,
-                                  const char text[])
+static rive::TextRun append(std::vector<rive::Unichar>* unichars,
+                            rive::rcp<rive::Font> font,
+                            float size,
+                            const char text[])
 {
     const uint8_t* ptr = (const uint8_t*)text;
     uint32_t n = 0;
@@ -23,10 +22,10 @@
         unichars->push_back(rive::UTF::NextUTF8(&ptr));
         n += 1;
     }
-    return {std::move(font), size, n};
+    return {std::move(font), size, n, 0};
 }
 
-static rcp<RenderFont> loadFont(const char* filename)
+static rcp<Font> loadFont(const char* filename)
 {
     FILE* fp = fopen("../../test/assets/RobotoFlex.ttf", "rb");
     REQUIRE(fp != nullptr);
@@ -38,7 +37,7 @@
     REQUIRE(fread(bytes.data(), 1, length, fp) == length);
     fclose(fp);
 
-    return HBRenderFont::Decode(bytes);
+    return HBFont::Decode(bytes);
 }
 
 TEST_CASE("line breaker separates words", "[line break]")
@@ -47,13 +46,15 @@
     REQUIRE(font != nullptr);
 
     // one two⏎ three
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
     truns.push_back(append(&unichars, font, 32.0f, "one two three"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 1);
-    auto run = shape.front();
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.runs.size() == 1);
+    const auto& run = paragraph.runs.front();
     REQUIRE(run.breaks.size() == 6);
     REQUIRE(run.breaks[0] == 0);
     REQUIRE(run.breaks[1] == 3);
@@ -68,15 +69,18 @@
     auto font = loadFont("../../test/assets/RobotoFlex.ttf");
     REQUIRE(font != nullptr);
 
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
     truns.push_back(append(&unichars, font, 32.0f, "one two thr"));
     truns.push_back(append(&unichars, font, 60.0f, "ee four"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 2);
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+
+    REQUIRE(paragraph.runs.size() == 2);
     {
-        auto run = shape.front();
+        const auto& run = paragraph.runs.front();
         REQUIRE(run.breaks.size() == 5);
         REQUIRE(run.breaks[0] == 0);
         REQUIRE(run.breaks[1] == 3);
@@ -85,7 +89,7 @@
         REQUIRE(run.breaks[4] == 8);
     }
     {
-        auto run = shape.back();
+        const auto& run = paragraph.runs.back();
         REQUIRE(run.breaks.size() == 3);
         REQUIRE(run.breaks[0] == 2);
         REQUIRE(run.breaks[1] == 3);
@@ -98,15 +102,16 @@
     auto font = loadFont("../../test/assets/RobotoFlex.ttf");
     REQUIRE(font != nullptr);
 
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
     truns.push_back(append(&unichars, font, 32.0f, "one two thr"));
-    truns.push_back(append(&unichars, font, 60.0f, "ee\n four"));
+    truns.push_back(append(&unichars, font, 60.0f, "ee\u2028 four"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 2);
+    auto paragraphs = font->shapeText(unichars, truns);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.runs.size() == 2);
     {
-        auto run = shape.front();
+        const auto& run = paragraph.runs.front();
         REQUIRE(run.breaks.size() == 5);
         REQUIRE(run.breaks[0] == 0);
         REQUIRE(run.breaks[1] == 3);
@@ -115,7 +120,7 @@
         REQUIRE(run.breaks[4] == 8);
     }
     {
-        auto run = shape.back();
+        const auto& run = paragraph.runs.back();
         REQUIRE(run.breaks.size() == 5);
         REQUIRE(run.breaks[0] == 2);
         REQUIRE(run.breaks[1] == 2);
@@ -131,42 +136,43 @@
     REQUIRE(font != nullptr);
 
     // one two⏎ three
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
     truns.push_back(append(&unichars, font, 32.0f, "one two three"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 1);
-    auto run = shape.front();
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.runs.size() == 1);
 
     // at 194 everything fits in one line
     {
-        auto lines = RenderGlyphLine::BreakLines(shape, 194.0f, RenderTextAlign::left);
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 194.0f);
         REQUIRE(lines.size() == 1);
         auto line = lines.back();
-        REQUIRE(line.startRun == 0);
-        REQUIRE(line.startIndex == 0);
-        REQUIRE(line.endRun == 0);
-        REQUIRE(line.endIndex == 13);
+        REQUIRE(line.startRunIndex == 0);
+        REQUIRE(line.startGlyphIndex == 0);
+        REQUIRE(line.endRunIndex == 0);
+        REQUIRE(line.endGlyphIndex == 13);
     }
     // at 191 "three" should pop to second line
     {
-        auto lines = RenderGlyphLine::BreakLines(shape, 191.0f, RenderTextAlign::left);
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 191.0f);
         REQUIRE(lines.size() == 2);
         {
             auto line = lines.front();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 0);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 7);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 0);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 7);
         }
 
         {
             auto line = lines.back();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 8);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 13);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 8);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 13);
         }
     }
 }
@@ -177,51 +183,52 @@
     REQUIRE(font != nullptr);
 
     // one two⏎ three
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
     truns.push_back(append(&unichars, font, 32.0f, "ab"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 1);
-    auto run = shape.front();
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.runs.size() == 1);
 
     {
-        auto lines = RenderGlyphLine::BreakLines(shape, 17.0f, RenderTextAlign::left);
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 17.0f);
         REQUIRE(lines.size() == 2);
         {
             auto line = lines.front();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 0);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 1);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 0);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 1);
         }
 
         {
             auto line = lines.back();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 1);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 2);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 1);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 2);
         }
     }
     // Test that it also handles 0 width.
     {
-        auto lines = RenderGlyphLine::BreakLines(shape, 0.0f, RenderTextAlign::left);
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 0.0f);
         REQUIRE(lines.size() == 2);
         {
             auto line = lines.front();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 0);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 1);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 0);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 1);
         }
 
         {
             auto line = lines.back();
-            REQUIRE(line.startRun == 0);
-            REQUIRE(line.startIndex == 1);
-            REQUIRE(line.endRun == 0);
-            REQUIRE(line.endIndex == 2);
+            REQUIRE(line.startRunIndex == 0);
+            REQUIRE(line.startGlyphIndex == 1);
+            REQUIRE(line.endRunIndex == 0);
+            REQUIRE(line.endGlyphIndex == 2);
         }
     }
 }
@@ -232,16 +239,78 @@
     REQUIRE(font != nullptr);
 
     // one two⏎ three
-    std::vector<rive::RenderTextRun> truns;
+    std::vector<rive::TextRun> truns;
     std::vector<rive::Unichar> unichars;
-    truns.push_back(append(&unichars, font, 32.0f, "hello look\nhere"));
+    truns.push_back(append(&unichars, font, 32.0f, "hello look\u2028here"));
 
-    auto shape = font->shapeText(unichars, truns);
-    REQUIRE(shape.size() == 1);
-    auto run = shape.front();
-
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.runs.size() == 1);
     {
-        auto lines = RenderGlyphLine::BreakLines(shape, 300.0f, RenderTextAlign::left);
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 300.0f);
         REQUIRE(lines.size() == 2);
     }
 }
+
+TEST_CASE("shaper separates paragraphs", "[shaper]")
+{
+    auto font = loadFont("../../test/assets/RobotoFlex.ttf");
+    REQUIRE(font != nullptr);
+
+    // one two⏎ three
+    std::vector<rive::TextRun> truns;
+    std::vector<rive::Unichar> unichars;
+    truns.push_back(append(&unichars, font, 32.0f, "hello look\u2028here\nsecond paragraph"));
+
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 2);
+    {
+        const auto& paragraph = paragraphs.front();
+        REQUIRE(paragraph.runs.size() == 1);
+        REQUIRE(paragraph.baseDirection == rive::TextDirection::ltr);
+
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 300.0f);
+        REQUIRE(lines.size() == 2);
+    }
+    {
+        const auto& paragraph = paragraphs.back();
+        REQUIRE(paragraph.runs.size() == 1);
+        REQUIRE(paragraph.baseDirection == rive::TextDirection::ltr);
+
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 300.0f);
+        REQUIRE(lines.size() == 1);
+    }
+}
+
+TEST_CASE("shaper handles RTL", "[shaper]")
+{
+    auto font = loadFont("../../test/assets/IBMPlexSansArabic-Regular.ttf");
+    REQUIRE(font != nullptr);
+
+    // one two⏎ three
+    std::vector<rive::TextRun> truns;
+    std::vector<rive::Unichar> unichars;
+    truns.push_back(append(&unichars, font, 32.0f, "لمفاتيح ABC DEF"));
+
+    auto paragraphs = font->shapeText(unichars, truns);
+    REQUIRE(paragraphs.size() == 1);
+    const auto& paragraph = paragraphs.front();
+    REQUIRE(paragraph.baseDirection == rive::TextDirection::rtl);
+    {
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 300.0f);
+        REQUIRE(lines.size() == 1);
+    }
+    {
+        auto lines = GlyphLine::BreakLines(paragraph.runs, 196.0f);
+        REQUIRE(lines.size() == 2);
+
+        // The second line should start with DEF as it's the first word to wrap.
+        const auto& line = lines.back();
+        const auto& run = paragraph.runs[line.startRunIndex];
+        auto index = run.textIndices[line.startGlyphIndex];
+        REQUIRE(unichars[index] == 'D');
+        REQUIRE(unichars[index + 1] == 'E');
+        REQUIRE(unichars[index + 2] == 'F');
+    }
+}
diff --git a/test/simple_array_test.cpp b/test/simple_array_test.cpp
index 78e7463..3263ba7 100644
--- a/test/simple_array_test.cpp
+++ b/test/simple_array_test.cpp
@@ -4,7 +4,7 @@
 
 #include <rive/simple_array.hpp>
 #include <catch.hpp>
-#include <rive/render_text.hpp>
+#include <rive/text.hpp>
 
 using namespace rive;
 
diff --git a/viewer/build/macosx/build_viewer.sh b/viewer/build/macosx/build_viewer.sh
index dbb4803..9dcac0d 100755
--- a/viewer/build/macosx/build_viewer.sh
+++ b/viewer/build/macosx/build_viewer.sh
@@ -46,12 +46,6 @@
     popd
 fi
 
-if [[ ! -d "$DEPENDENCIES/harfbuzz" ]]; then
-    pushd $DEPENDENCIES_SCRIPTS
-    ./get_harfbuzz.sh
-    popd
-fi
-
 if [ $RENDERER = "skia" ]; then
     pushd ../../../skia/renderer/build/macosx
     ./build_skia_renderer.sh text $@
@@ -68,7 +62,7 @@
 
 pushd ..
 
-$PREMAKE --file=./premake5_viewer.lua gmake2 --graphics=$GRAPHICS --renderer=$RENDERER --with_rive_tools --with_rive_text
+$PREMAKE --scripts=../../build --file=./premake5_viewer.lua gmake2 --graphics=$GRAPHICS --renderer=$RENDERER --with_rive_tools --with_rive_text
 
 for var in "$@"; do
     if [[ $var = "clean" ]]; then
diff --git a/viewer/build/premake5_viewer.lua b/viewer/build/premake5_viewer.lua
index a7d79a0..d01b75e 100644
--- a/viewer/build/premake5_viewer.lua
+++ b/viewer/build/premake5_viewer.lua
@@ -12,7 +12,6 @@
 skia = dependencies .. '/skia'
 libpng = dependencies .. '/libpng'
 
-dofile(path.join(path.getabsolute(dependencies) .. '/../..', 'premake5_harfbuzz.lua'))
 if _OPTIONS.renderer == 'tess' then
     dofile(path.join(path.getabsolute(dependencies) .. '/../..', 'premake5_libpng.lua'))
     dofile(path.join(path.getabsolute(rive_tess) .. '/build', 'premake5_tess.lua'))
@@ -38,16 +37,17 @@
     includedirs {
         '../include',
         rive .. '/include',
-        rive .. '/skia/renderer/include', -- for renderfont backends
+        rive .. '/skia/renderer/include', -- for font backends
         dependencies,
         dependencies .. '/sokol',
-        dependencies .. '/imgui',
-        dependencies .. '/harfbuzz/src'
+        dependencies .. '/imgui'
     }
 
     links {
         'rive',
-        'rive_harfbuzz'
+        'rive_harfbuzz',
+        -- 'rive_fribidi'
+        'rive_sheenbidi'
     }
 
     libdirs {
@@ -57,7 +57,6 @@
     files {
         '../src/**.cpp',
         rive .. '/utils/**.cpp',
-        rive .. '/skia/renderer/src/renderfont_coretext.cpp',
         dependencies .. '/imgui/imgui.cpp',
         dependencies .. '/imgui/imgui_widgets.cpp',
         dependencies .. '/imgui/imgui_tables.cpp',
diff --git a/viewer/include/viewer/viewer_content.hpp b/viewer/include/viewer/viewer_content.hpp
index e607929..ad7ba60 100644
--- a/viewer/include/viewer/viewer_content.hpp
+++ b/viewer/include/viewer/viewer_content.hpp
@@ -14,7 +14,7 @@
 {
 class Renderer;
 class Factory;
-class RenderFont;
+class Font;
 } // namespace rive
 
 class ViewerContent
@@ -65,7 +65,7 @@
     static rive::Factory* RiveFactory();
 
     // Abstracts which font backend is currently used.
-    static rive::rcp<rive::RenderFont> DecodeFont(rive::Span<const uint8_t>);
+    static rive::rcp<rive::Font> DecodeFont(rive::Span<const uint8_t>);
 };
 
 #endif
diff --git a/viewer/include/viewer/viewer_host.hpp b/viewer/include/viewer/viewer_host.hpp
index bf64439..1993cfe 100644
--- a/viewer/include/viewer/viewer_host.hpp
+++ b/viewer/include/viewer/viewer_host.hpp
@@ -7,7 +7,7 @@
 
 #include "rive/factory.hpp"
 #include "rive/renderer.hpp"
-#include "rive/render_text.hpp"
+#include "rive/text.hpp"
 
 #include "sokol_gfx.h"
 
diff --git a/viewer/src/viewer_content/text_content.cpp b/viewer/src/viewer_content/text_content.cpp
index 44e70f4..d054482 100644
--- a/viewer/src/viewer_content/text_content.cpp
+++ b/viewer/src/viewer_content/text_content.cpp
@@ -8,12 +8,12 @@
 #include "rive/math/raw_path.hpp"
 #include "rive/factory.hpp"
 #include "rive/refcnt.hpp"
-#include "rive/render_text.hpp"
-#include "rive/text/line_breaker.hpp"
+#include "rive/text.hpp"
+#include <algorithm>
 
-using RenderFontTextRuns = std::vector<rive::RenderTextRun>;
-using RenderFontGlyphRuns = rive::SimpleArray<rive::RenderGlyphRun>;
-using RenderFontFactory = rive::rcp<rive::RenderFont> (*)(const rive::Span<const uint8_t>);
+using FontTextRuns = std::vector<rive::TextRun>;
+using FontGlyphRuns = rive::SimpleArray<rive::GlyphRun>;
+using FontFactory = rive::rcp<rive::Font> (*)(const rive::Span<const uint8_t>);
 
 static bool ws(rive::Unichar c) { return c <= ' '; }
 
@@ -41,60 +41,95 @@
     return breaks;
 }
 
-static void drawrun(rive::Factory* factory,
-                    rive::Renderer* renderer,
-                    const rive::RenderGlyphRun& run,
-                    unsigned startIndex,
-                    unsigned endIndex,
-                    rive::Vec2D origin)
+static float drawrun(rive::Factory* factory,
+                     rive::Renderer* renderer,
+                     const rive::GlyphRun& run,
+                     unsigned startIndex,
+                     unsigned endIndex,
+                     rive::Vec2D origin)
 {
     auto font = run.font.get();
     const auto scale = rive::Mat2D::fromScale(run.size, run.size);
     auto paint = factory->makeRenderPaint();
     paint->color(0xFFFFFFFF);
 
+    float x = origin.x;
     assert(startIndex >= 0 && endIndex <= run.glyphs.size());
-    for (size_t i = startIndex; i < endIndex; ++i)
+    int i, end, inc;
+    if (run.dir == rive::TextDirection::rtl)
     {
-        auto trans = rive::Mat2D::fromTranslate(origin.x + run.xpos[i], origin.y);
+        i = endIndex - 1;
+        end = startIndex - 1;
+        inc = -1;
+    }
+    else
+    {
+        i = startIndex;
+        end = endIndex;
+        inc = 1;
+    }
+    while (i != end)
+    {
+        auto trans = rive::Mat2D::fromTranslate(x, origin.y);
+        x += run.advances[i];
         auto rawpath = font->getPath(run.glyphs[i]);
         rawpath.transformInPlace(trans * scale);
         auto path = factory->makeRenderPath(rawpath, rive::FillRule::nonZero);
         renderer->drawPath(path.get(), paint.get());
+        i += inc;
     }
+    return x;
 }
 
-static void drawpara(rive::Factory* factory,
-                     rive::Renderer* renderer,
-                     rive::Span<const rive::RenderGlyphLine> lines,
-                     rive::Span<const rive::RenderGlyphRun> runs,
-                     rive::Vec2D origin)
+static float drawpara(rive::Factory* factory,
+                      rive::Renderer* renderer,
+                      const rive::Paragraph& paragraph,
+                      const rive::SimpleArray<rive::GlyphLine>& lines,
+                      rive::Vec2D origin)
 {
+
     for (const auto& line : lines)
     {
-        const float x0 = runs[line.startRun].xpos[line.startIndex];
-        int startGIndex = line.startIndex;
-        for (int runIndex = line.startRun; runIndex <= line.endRun; ++runIndex)
+
+        float x = line.startX + origin.x;
+        int runIndex, endRun, runInc;
+        if (paragraph.baseDirection == rive::TextDirection::rtl)
         {
-            const auto& run = runs[runIndex];
-            int endGIndex = runIndex == line.endRun ? line.endIndex : run.glyphs.size();
-            drawrun(factory,
-                    renderer,
-                    run,
-                    startGIndex,
-                    endGIndex,
-                    {origin.x - x0 + line.startX, origin.y + line.baseline});
-            startGIndex = 0;
+            runIndex = line.endRunIndex;
+            endRun = line.startRunIndex - 1;
+            runInc = -1;
+        }
+        else
+        {
+            runIndex = line.startRunIndex;
+            endRun = line.endRunIndex + 1;
+            runInc = 1;
+        }
+        while (runIndex != endRun)
+        {
+            const auto& run = paragraph.runs[runIndex];
+            int startGIndex = runIndex == line.startRunIndex ? line.startGlyphIndex : 0;
+            int endGIndex = runIndex == line.endRunIndex ? line.endGlyphIndex : run.glyphs.size();
+
+            x = drawrun(factory,
+                        renderer,
+                        run,
+                        startGIndex,
+                        endGIndex,
+                        {x, origin.y + line.baseline});
+
+            runIndex += runInc;
         }
     }
+    return origin.y + lines.back().bottom;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef RIVE_USING_HAFBUZZ_FONTS
-static rive::rcp<rive::RenderFont> load_fallback_font(rive::Span<const rive::Unichar> missing)
+static rive::rcp<rive::Font> load_fallback_font(rive::Span<const rive::Unichar> missing)
 {
-    static rive::rcp<rive::RenderFont> gFallbackFont;
+    static rive::rcp<rive::Font> gFallbackFont;
 
     printf("missing chars:");
     for (auto m : missing)
@@ -121,7 +156,7 @@
         fclose(fp);
 
         assert(bytesRead == size);
-        gFallbackFont = HBRenderFont::Decode(bytes);
+        gFallbackFont = HBFont::Decode(bytes);
     }
     return gFallbackFont;
 }
@@ -147,10 +182,10 @@
     renderer->drawPath(path.get(), paint.get());
 }
 
-static rive::RenderTextRun append(std::vector<rive::Unichar>* unichars,
-                                  rive::rcp<rive::RenderFont> font,
-                                  float size,
-                                  const char text[])
+static rive::TextRun append(std::vector<rive::Unichar>* unichars,
+                            rive::rcp<rive::Font> font,
+                            float size,
+                            const char text[])
 {
     const uint8_t* ptr = (const uint8_t*)text;
     uint32_t n = 0;
@@ -167,15 +202,15 @@
     std::vector<rive::Unichar> m_unichars;
     std::vector<int> m_breaks;
 
-    std::vector<RenderFontGlyphRuns> m_gruns;
+    rive::SimpleArray<rive::Paragraph> m_paragraphs;
     rive::Mat2D m_xform;
     float m_width = 300;
     bool m_autoWidth = false;
     int m_align = 0;
 
-    RenderFontTextRuns make_truns(RenderFontFactory fact)
+    FontTextRuns make_truns(FontFactory fact)
     {
-        auto loader = [fact](const char filename[]) -> rive::rcp<rive::RenderFont> {
+        auto loader = [fact](const char filename[]) -> rive::rcp<rive::Font> {
             auto bytes = ViewerContent::LoadFile(filename);
             if (bytes.size() == 0)
             {
@@ -188,27 +223,55 @@
         const char* fontFiles[] = {
             "../../../test/assets/RobotoFlex.ttf",
             "../../../test/assets/LibreBodoni-Italic-VariableFont_wght.ttf",
+            "../../../test/assets/IBMPlexSansArabic-Regular.ttf",
         };
 
         auto font0 = loader(fontFiles[0]);
-        auto font1 = loader(fontFiles[1]);
-        assert(font0);
-        assert(font1);
+        // auto font1 = loader(fontFiles[1]);
+        auto font2 = loader(fontFiles[2]);
+        // assert(font0);
+        // assert(font1);
+        assert(font2);
 
-        rive::RenderFont::Coord c1 = {'wght', 100.f}, c2 = {'wght', 800.f};
+        rive::Font::Coord c1 = {'wght', 100.f}, c2 = {'wght', 800.f};
 
-        RenderFontTextRuns truns;
+        FontTextRuns truns;
 
-        // truns.push_back(append(&m_unichars, font0->makeAtCoord(c2), 60, "U"));
+        // truns.push_back(
+        //     append(&m_unichars, font0->makeAtCoord(c2), 32, "No one ever left alive in "));
+        // truns.push_back(append(&m_unichars, font0->makeAtCoord(c2), 54, "nineteen hundred"));
         // truns.push_back(append(&m_unichars, font0->makeAtCoord(c1), 30, "ne漢字asy"));
-        // truns.push_back(append(&m_unichars, font1, 30, " fits the \ncRown"));
+
+        // truns.push_back(append(&m_unichars, font2, 30, " its the  "));
+        // truns.push_back(append(&m_unichars, font2, 40, "cRown"));
+        // truns.push_back(append(&m_unichars, font2, 30, "a b c d"));
+
         // truns.push_back(append(&m_unichars, font1->makeAtCoord(c1), 30, " that often"));
         // truns.push_back(append(&m_unichars, font0, 30, " lies the head."));
         // truns.push_back(append(&m_unichars, font0->makeAtCoord(c2), 60, "hi one two"));
 
-        truns.push_back(append(&m_unichars, font0, 32.0f, "one two three"));
-        truns.push_back(append(&m_unichars, font0, 42.0f, "OT\nHER\n"));
-        truns.push_back(append(&m_unichars, font1, 62.0f, "VERY LARGE FONT HERE"));
+        // truns.push_back(append(&m_unichars, font2, 32.0f, "في 10-12 آذار 1997 بمدينة"));
+        // truns.push_back(append(&m_unichars, font2, 32.0f, "في 10-12 آذار 1997 بمدينة"));
+
+        truns.push_back(append(&m_unichars,
+                               font2,
+                               32.0f,
+                               // clang-format off
+                               "لمفاتيح ABC DEF"));
+        //    "لمفاتيح ABC DEF في 10-12 آذار 1997 بمدينة\nabc def ghi jkl mnop\nلكن لا بد أن أوضح لك
+        //    أن كل"));
+        // "hello look\u2028here\nsecond paragraph"));
+
+        // clang-format on
+
+        // truns.push_back(append(&m_unichars, font2, 32.0f, "abc def\nghijkl"));
+
+        // truns.push_back(append(&m_unichars, font2, 32.0f, "DEF دنة"));
+
+        // truns.push_back(append(&m_unichars, font2, 32.0f, "AفيB"));
+
+        // truns.push_back(append(&m_unichars, font0, 42.0f, "OT\nHER\n"));
+        // truns.push_back(append(&m_unichars, font1, 62.0f, "VERY LARGE FONT HERE"));
         // truns.push_back(
         //     append(&m_unichars, font0, 52.0f, "one two three\n\n\nfour five six seven"));
 
@@ -224,21 +287,47 @@
     TextContent()
     {
         auto truns = this->make_truns(ViewerContent::DecodeFont);
-        m_gruns.push_back(truns[0].font->shapeText(m_unichars, truns));
+        m_paragraphs = truns[0].font->shapeText(m_unichars, truns);
 
         m_xform = rive::Mat2D::fromTranslate(10, 0) * rive::Mat2D::fromScale(3, 3);
     }
 
-    void draw(rive::Renderer* renderer, float width, const RenderFontGlyphRuns& gruns)
+    void draw(rive::Renderer* renderer,
+              float width,
+              const rive::SimpleArray<rive::Paragraph>& paragraphs)
     {
+
         renderer->save();
         renderer->transform(m_xform);
+        float y = 0.0f;
+        float paragraphWidth = m_autoWidth ? -1.0f : width;
 
-        auto lines = rive::RenderGlyphLine::BreakLines(gruns,
-                                                       m_autoWidth ? -1.0f : width,
-                                                       (rive::RenderTextAlign)m_align);
+        rive::SimpleArray<rive::SimpleArray<rive::GlyphLine>>* lines =
+            new rive::SimpleArray<rive::SimpleArray<rive::GlyphLine>>(paragraphs.size());
+        rive::SimpleArray<rive::SimpleArray<rive::GlyphLine>>& linesRef = *lines;
+        size_t paragraphIndex = 0;
+        for (auto& para : paragraphs)
+        {
+            linesRef[paragraphIndex] =
+                rive::GlyphLine::BreakLines(para.runs, m_autoWidth ? -1.0f : width);
 
-        drawpara(RiveFactory(), renderer, lines, gruns, {0, 0});
+            if (m_autoWidth)
+            {
+                paragraphWidth =
+                    std::max(paragraphWidth,
+                             rive::GlyphLine::ComputeMaxWidth(linesRef[paragraphIndex], para.runs));
+            }
+        }
+        paragraphIndex = 0;
+        for (auto& para : paragraphs)
+        {
+            rive::SimpleArray<rive::GlyphLine>& lines = linesRef[paragraphIndex++];
+            rive::GlyphLine::ComputeLineSpacing(lines,
+                                                para.runs,
+                                                paragraphWidth,
+                                                (rive::TextAlign)m_align);
+            y = drawpara(RiveFactory(), renderer, para, lines, {0, y}) + 20.0f;
+        }
         if (!m_autoWidth)
         {
             draw_line(RiveFactory(), renderer, width);
@@ -249,11 +338,7 @@
 
     void handleDraw(rive::Renderer* renderer, double) override
     {
-        for (auto& grun : m_gruns)
-        {
-            this->draw(renderer, m_width, grun);
-            renderer->translate(1200, 0);
-        }
+        this->draw(renderer, m_width, m_paragraphs);
     }
 
     void handleResize(int width, int height) override {}
diff --git a/viewer/src/viewer_content/textpath_content.cpp b/viewer/src/viewer_content/textpath_content.cpp
index f511a63..0b78ae6 100644
--- a/viewer/src/viewer_content/textpath_content.cpp
+++ b/viewer/src/viewer_content/textpath_content.cpp
@@ -1,3 +1,4 @@
+
 /*
  * Copyright 2022 Rive
  */
@@ -8,18 +9,16 @@
 #include "rive/math/raw_path.hpp"
 #include "rive/refcnt.hpp"
 #include "rive/factory.hpp"
-#include "rive/render_text.hpp"
+#include "rive/text.hpp"
 #include "rive/math/contour_measure.hpp"
-#include "rive/text/line_breaker.hpp"
 
 using namespace rive;
+#if 0
+using FontTextRuns = std::vector<TextRun>;
+using FontGlyphRuns = rive::SimpleArray<GlyphRun>;
+using FontFactory = rcp<Font> (*)(const Span<const uint8_t>);
 
-using RenderFontTextRuns = std::vector<RenderTextRun>;
-using RenderFontGlyphRuns = rive::SimpleArray<RenderGlyphRun>;
-using RenderFontFactory = rcp<RenderFont> (*)(const Span<const uint8_t>);
-
-template <typename Handler>
-void visit(const Span<RenderGlyphRun>& gruns, Vec2D origin, Handler proc)
+template <typename Handler> void visit(const Span<GlyphRun>& gruns, Vec2D origin, Handler proc)
 {
     for (const auto& gr : gruns)
     {
@@ -99,8 +98,7 @@
     fill_rect(renderer, {p.x - r, p.y - r, p.x + r, p.y + r}, paint);
 }
 
-static RenderTextRun
-append(std::vector<Unichar>* unichars, rcp<RenderFont> font, float size, const char text[])
+static TextRun append(std::vector<Unichar>* unichars, rcp<Font> font, float size, const char text[])
 {
     const uint8_t* ptr = (const uint8_t*)text;
     uint32_t n = 0;
@@ -115,7 +113,7 @@
 class TextPathContent : public ViewerContent
 {
     std::vector<Unichar> m_unichars;
-    RenderFontGlyphRuns m_gruns;
+    FontGlyphRuns m_gruns;
     std::unique_ptr<RenderPaint> m_paint;
     AABB m_gbounds;
 
@@ -133,9 +131,9 @@
           m_windowWidth = 1, // %
         m_windowOffset = 0;  // %
 
-    RenderFontTextRuns make_truns(RenderFontFactory fact)
+    FontTextRuns make_truns(FontFactory fact)
     {
-        auto loader = [fact](const char filename[]) -> rcp<RenderFont> {
+        auto loader = [fact](const char filename[]) -> rcp<Font> {
             auto bytes = ViewerContent::LoadFile(filename);
             if (bytes.size() == 0)
             {
@@ -155,9 +153,9 @@
         assert(font0);
         assert(font1);
 
-        RenderFont::Coord c1 = {'wght', 100.f}, c2 = {'wght', 800.f};
+        Font::Coord c1 = {'wght', 100.f}, c2 = {'wght', 800.f};
 
-        RenderFontTextRuns truns;
+        FontTextRuns truns;
 
         truns.push_back(append(&m_unichars, font0->makeAtCoord(c2), 60, "U"));
         truns.push_back(append(&m_unichars, font0->makeAtCoord(c1), 30, "ne漢字asy"));
@@ -171,7 +169,7 @@
 public:
     TextPathContent()
     {
-        auto compute_bounds = [](const rive::SimpleArray<RenderGlyphRun>& gruns) {
+        auto compute_bounds = [](const rive::SimpleArray<GlyphRun>& gruns) {
             AABB bounds = {};
             for (const auto& gr : gruns)
             {
@@ -216,7 +214,7 @@
         }
     }
 
-    static size_t count_glyphs(const RenderFontGlyphRuns& gruns)
+    static size_t count_glyphs(const FontGlyphRuns& gruns)
     {
         size_t n = 0;
         for (const auto& gr : gruns)
@@ -228,9 +226,9 @@
 
     void modify(float amount) { m_paint->color(0xFFFFFFFF); }
 
-    void draw(Renderer* renderer, const RenderFontGlyphRuns& gruns)
+    void draw(Renderer* renderer, const FontGlyphRuns& gruns)
     {
-        auto get_path = [this](const RenderGlyphRun& run, int index, float dx) {
+        auto get_path = [this](const GlyphRun& run, int index, float dx) {
             auto path = run.font->getPath(run.glyphs[index]);
             path.transformInPlace(Mat2D::fromTranslate(run.xpos[index] + dx, m_offsetY) *
                                   Mat2D::fromScale(run.size, run.size * m_scaleY));
@@ -406,3 +404,6 @@
 {
     return std::make_unique<TextPathContent>();
 }
+#else
+std::unique_ptr<ViewerContent> ViewerContent::TextPath(const char filename[]) { return nullptr; }
+#endif
diff --git a/viewer/src/viewer_content/viewer_content.cpp b/viewer/src/viewer_content/viewer_content.cpp
index e60dfd2..44a63b3 100644
--- a/viewer/src/viewer_content/viewer_content.cpp
+++ b/viewer/src/viewer_content/viewer_content.cpp
@@ -67,17 +67,8 @@
 
 rive::Factory* ViewerContent::RiveFactory() { return ViewerHost::Factory(); }
 
-#ifdef RIVE_BUILD_FOR_APPLE
-// note: we can use harfbuzz even on apple ... (if we want)
-#include "renderfont_coretext.hpp"
-rive::rcp<rive::RenderFont> ViewerContent::DecodeFont(rive::Span<const uint8_t> span)
+#include "rive/text/font_hb.hpp"
+rive::rcp<rive::Font> ViewerContent::DecodeFont(rive::Span<const uint8_t> span)
 {
-    return CoreTextRenderFont::Decode(span);
+    return HBFont::Decode(span);
 }
-#else
-#include "renderfont_hb.hpp"
-rive::rcp<rive::RenderFont> ViewerContent::DecodeFont(rive::Span<const uint8_t> span)
-{
-    return HBRenderFont::Decode(span);
-}
-#endif