diff --git a/include/rive/render_text.hpp b/include/rive/render_text.hpp
new file mode 100644
index 0000000..20d7206
--- /dev/null
+++ b/include/rive/render_text.hpp
@@ -0,0 +1,76 @@
+/*
+ * 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"
+
+namespace rive {
+
+using Unichar = int32_t;
+using GlyphID = uint16_t;
+
+class RenderFont : public RefCnt {
+public:
+    // 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;
+};
+
+struct RenderTextRun {
+    rcp<RenderFont> font;
+    float           size;
+    uint32_t        unicharCount;
+};
+
+struct RenderGlyphRun {
+    rcp<RenderFont>         font;
+    float                   size;
+    uint32_t                startTextIndex;
+
+    std::vector<GlyphID>    glyphs;
+    std::vector<float>      xpos;   // xpos.size() == glyphs.size() + 1
+};
+
+} // namespace rive
+#endif
diff --git a/include/rive/renderer.hpp b/include/rive/renderer.hpp
index 440d371..85559b9 100644
--- a/include/rive/renderer.hpp
+++ b/include/rive/renderer.hpp
@@ -37,39 +37,6 @@
         size_t count() const { return m_Count; }
     };
 
-    class RenderFont {
-    public:
-        struct AxisInfo {
-            uint32_t    tag;
-            float       min;
-            float       def;    // default value
-            float       max;
-        };
-        
-        virtual int countAxes() const { return 0; }
-        virtual std::vector<AxisInfo> getAxes() const { return std::vector<AxisInfo>; }
-        
-        // TODO: getGlyphPath(index) -> rawpath
-    };
-
-    struct RenderTextRun {
-        rcp<RenderFont> font;
-        float           size;
-        uint32_t        textCount;  // number of unichars in this run in text[]
-    };
-
-    struct RenderGlyphRun {
-        rcp<RenderFont>         font;
-        float                   size;
-
-        size_t                  startTextIndex;
-        std::vector<uint16_t>   glyphs;
-        std::vector<float>      xpos;   // xpos.size() == glyphs.size() + 1
-    };
-
-    extern std::vector<RenderGlyphRun> shapeText(const uint32_t text[], size_t textCount,
-                                                 const RenderTextRun[], size_t runCount);
-
     enum class RenderPaintStyle { stroke, fill };
 
     enum class RenderTileMode {
diff --git a/skia/viewer/src/drawtext.cpp b/skia/viewer/src/drawtext.cpp
new file mode 100644
index 0000000..6a5af71
--- /dev/null
+++ b/skia/viewer/src/drawtext.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#include "skia_factory.hpp"
+#include "skia_renderer.hpp"
+#include "skia_rive_fontmgr.hpp"
+
+#include <string>
+
+static void drawrun(rive::Factory* factory, rive::Renderer* renderer,
+                    const rive::RenderGlyphRun& run, 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);
+
+    for (size_t i = 0; i < run.glyphs.size(); ++i) {
+        auto trans = rive::Mat2D::fromTranslate(origin.x + run.xpos[i], origin.y);
+        auto rawpath = font->getPath(run.glyphs[i]);
+        rawpath.transformInPlace(trans * scale);
+        auto path = factory->makeRenderPath(rawpath.points(), rawpath.verbsU8(), rive::FillRule::nonZero);
+        renderer->drawPath(path.get(), paint.get());
+    }
+}
+
+struct UniString {
+    std::vector<rive::Unichar> array;
+
+    UniString(const char text[]) {
+        while (*text) {
+            array.push_back(*text++);
+        }
+    }
+};
+
+static std::string tagstr(uint32_t tag) {
+    std::string s("abcd");
+    s[0] = (tag >> 24) & 0xFF;
+    s[1] = (tag >> 16) & 0xFF;
+    s[2] = (tag >>  8) & 0xFF;
+    s[3] = (tag >>  0) & 0xFF;
+    return s;
+}
+
+void drawtext(rive::Factory* factory, rive::Renderer* renderer) {
+    static std::vector<rive::RenderGlyphRun> gruns;
+
+    if (gruns.size() == 0) {
+        SkiaRiveFontMgr fmgr;
+
+        auto font0 = fmgr.findFont("Times New Roman");
+        auto font1 = fmgr.findFont("Skia");
+
+        if (false) {
+            auto axes = font1->getAxes();
+            for (auto a : axes) {
+                printf("%s %g %g %g\n", tagstr(a.tag).c_str(), a.min, a.def, a.max);
+            }
+            auto coords = font1->getCoords();
+            for (auto c : coords) {
+                printf("%s %g\n", tagstr(c.axis).c_str(), c.value);
+            }
+        }
+
+        rive::RenderFont::Coord c0 = {'wght', 0.5f},
+                                c1 = {'wght', 2.0f};
+
+        UniString str("Uneasy lies the head that wears a crown.");
+        rive::RenderTextRun truns[] = {
+            { font0, 60, 1 },
+            { font0, 30, 6 },
+            { font1->makeAtCoord(c0), 30, 4 },
+            { font1, 30, 4 },
+            { font1->makeAtCoord(c1), 30, 5 },
+            { font0, 30, 20 },
+        };
+
+        gruns = fmgr.shapeText(rive::toSpan(str.array), rive::Span(truns, 6));
+    }
+
+    renderer->save();
+    renderer->scale(3, 3);
+    for (const auto& g : gruns) {
+        drawrun(factory, renderer, g, {10, 50});
+    }
+    renderer->restore();
+}
+
diff --git a/skia/viewer/src/fontmgr.cpp b/skia/viewer/src/fontmgr.cpp
new file mode 100644
index 0000000..4298c3c
--- /dev/null
+++ b/skia/viewer/src/fontmgr.cpp
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#include "rive/factory.hpp"
+#include "rive/render_text.hpp"
+#include "skia_rive_fontmgr.hpp"
+
+#include "include/core/SkTypeface.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPath.h"
+
+class SkiaRenderFont : public rive::RenderFont {
+public:
+    sk_sp<SkTypeface> m_Typeface;
+
+    SkiaRenderFont(sk_sp<SkTypeface> tf) : m_Typeface(std::move(tf)) {}
+
+    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;
+};
+
+std::vector<rive::RenderFont::Axis> SkiaRenderFont::getAxes() const {
+    std::vector<rive::RenderFont::Axis> axes;
+    const int count = m_Typeface->getVariationDesignParameters(nullptr, 0);
+    if (count > 0) {
+        std::vector<SkFontParameters::Variation::Axis> src(count);
+        (void)m_Typeface->getVariationDesignParameters(src.data(), count);
+        axes.resize(count);
+        for (int i = 0; i < count; ++i) {
+            axes[i] = { src[i].tag, src[i].min, src[i].def, src[i].max };
+        }
+    }
+    return axes;
+}
+
+std::vector<rive::RenderFont::Coord> SkiaRenderFont::getCoords() const {
+    int count = m_Typeface->getVariationDesignPosition(nullptr, 0);
+    std::vector<SkFontArguments::VariationPosition::Coordinate> skcoord(count);
+    m_Typeface->getVariationDesignPosition(skcoord.data(), count);
+
+    std::vector<rive::RenderFont::Coord> coords(count);
+    for (int i = 0; i < count; ++i) {
+        coords[i] = { skcoord[i].axis, skcoord[i].value };
+    }
+    return coords;
+}
+
+rive::rcp<rive::RenderFont> SkiaRenderFont::makeAtCoords(rive::Span<const Coord> coords) const {
+    const int count = (int)coords.size();
+    SkAutoSTArray<16, SkFontArguments::VariationPosition::Coordinate> storage(count);
+    for (size_t i = 0; i < count; ++i) {
+        storage[i].axis = coords[i].axis;
+        storage[i].value = coords[i].value;
+    }
+    SkFontArguments args;
+    args.setVariationDesignPosition({storage.get(), count});
+
+    auto face = m_Typeface->makeClone(args);
+
+    if (face->uniqueID() == m_Typeface->uniqueID()) {
+        auto self = const_cast<SkiaRenderFont*>(this);
+        return rive::rcp<rive::RenderFont>(rive::safe_ref(self));
+    } else {
+        return rive::rcp<rive::RenderFont>(new SkiaRenderFont(std::move(face)));
+    }
+}
+
+static inline rive::Vec2D rv(SkPoint p) { return rive::Vec2D(p.fX, p.fY); }
+
+static void setupFont(SkFont* font) {
+    font->setLinearMetrics(true);
+    font->setBaselineSnap(false);
+    font->setHinting(SkFontHinting::kNone);
+}
+
+rive::RawPath SkiaRenderFont::getPath(rive::GlyphID glyph) const {
+    SkFont font(m_Typeface, 1.0f);
+    setupFont(&font);
+
+    SkPath skpath;
+    font.getPath(glyph, &skpath);
+
+    rive::RawPath rpath;
+    SkPath::RawIter iter(skpath);
+    SkPoint pts[4];
+    bool done = false;
+    while (!done) {
+        switch (iter.next(pts)) {
+            case SkPath::kMove_Verb:  rpath.move (rv(pts[0])); break;
+            case SkPath::kLine_Verb:  rpath.line (rv(pts[1])); break;
+            case SkPath::kQuad_Verb:  rpath.quad (rv(pts[1]), rv(pts[2])); break;
+            case SkPath::kConic_Verb: rpath.quad (rv(pts[1]), rv(pts[2])); break;  // TODO: convert
+            case SkPath::kCubic_Verb: rpath.cubic(rv(pts[1]), rv(pts[2]), rv(pts[3])); break;
+            case SkPath::kClose_Verb: rpath.close(); break;
+            case SkPath::kDone_Verb: done = true; break;
+        }
+    }
+    return rpath;
+}
+
+///////////////////////////////////////////////////////////
+
+rive::rcp<rive::RenderFont> SkiaRiveFontMgr::decodeFont(rive::Span<const uint8_t> data) {
+    auto tf = SkTypeface::MakeDefault(); // ignoring data for now
+    return rive::rcp<rive::RenderFont>(new SkiaRenderFont(std::move(tf)));
+}
+
+rive::rcp<rive::RenderFont> SkiaRiveFontMgr::findFont(const char name[]) {
+    auto tf = SkTypeface::MakeFromName(name, SkFontStyle());
+    if (!tf) {
+        tf = SkTypeface::MakeDefault();
+    }
+    return rive::rcp<rive::RenderFont>(new SkiaRenderFont(std::move(tf)));
+}
+
+static float shapeRun(rive::RenderGlyphRun* grun, const rive::RenderTextRun& trun,
+                      const rive::Unichar text[], size_t textOffset, float origin) {
+    grun->font = trun.font;
+    grun->size = trun.size;
+    grun->startTextIndex = textOffset;
+    grun->glyphs.resize(trun.unicharCount);
+    grun->xpos.resize(trun.unicharCount + 1);
+
+    const int count = SkToInt(trun.unicharCount);
+
+    SkiaRenderFont* rfont = static_cast<SkiaRenderFont*>(trun.font.get());
+    rfont->m_Typeface->unicharsToGlyphs(text + textOffset, count, grun->glyphs.data());
+
+    SkFont font(rfont->m_Typeface, grun->size);
+    setupFont(&font);
+
+    // We get 'widths' from skia, but then turn them into xpos
+    // this will write count values, but xpos has count+1 slots
+    font.getWidths(grun->glyphs.data(), count, grun->xpos.data());
+    for (auto& xp : grun->xpos) {
+        auto width = xp;
+        xp = origin;
+        origin += width;
+    }
+
+    return grun->xpos.data()[count];
+}
+
+std::vector<rive::RenderGlyphRun>
+SkiaRiveFontMgr::shapeText(rive::Span<const rive::Unichar> text,
+                           rive::Span<const rive::RenderTextRun> truns) {
+    std::vector<rive::RenderGlyphRun> gruns;
+
+    // sanity check
+    size_t count = 0;
+    for (const auto& tr : truns) {
+        count += tr.unicharCount;
+    }
+    if (count > text.size()) {
+        return gruns;   // not enough text, so abort
+    }
+
+    gruns.resize(truns.size());
+    int i = 0;
+    size_t offset = 0;
+    float origin = 0;
+    for (const auto& tr : truns) {
+        origin = shapeRun(&gruns[i], tr, text.data(), offset, origin);
+        offset += tr.unicharCount;
+        i += 1;
+    }
+
+    return gruns;
+}
diff --git a/skia/viewer/src/main.cpp b/skia/viewer/src/main.cpp
index 7901254..50a170c 100644
--- a/skia/viewer/src/main.cpp
+++ b/skia/viewer/src/main.cpp
@@ -45,6 +45,8 @@
 
 sk_sp<SkImage> gImage;
 
+extern void drawtext(rive::Factory*, rive::Renderer*);
+
 static void delete_file() {
     stateMachineIndex = -1;
     animationIndex = -1;
@@ -347,6 +349,10 @@
                 canvas->drawImage(gImage, 0, 0);
             }
         }
+        if (true) {
+            rive::SkiaRenderer renderer(canvas);
+            drawtext(&skiaFactory, &renderer);
+        }
         context->flush();
 
         ImGui_ImplOpenGL3_NewFrame();
diff --git a/skia/viewer/src/skia_rive_fontmgr.hpp b/skia/viewer/src/skia_rive_fontmgr.hpp
new file mode 100644
index 0000000..9777b11
--- /dev/null
+++ b/skia/viewer/src/skia_rive_fontmgr.hpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#ifndef _RIVE_SKIA_FONTMGR_HPP_
+#define _RIVE_SKIA_FONTMGR_HPP_
+
+#include "rive/refcnt.hpp"
+#include "rive/span.hpp"
+#include "rive/render_text.hpp"
+
+// This is a working model for how we might extend Factory.hpp
+class SkiaRiveFontMgr {
+public:
+    rive::rcp<rive::RenderFont> decodeFont(rive::Span<const uint8_t>);
+    rive::rcp<rive::RenderFont> findFont(const char name[]);
+    std::vector<rive::RenderGlyphRun> shapeText(rive::Span<const rive::Unichar> text,
+                                                rive::Span<const rive::RenderTextRun> runs);
+
+};
+
+#endif