diff --git a/lime/text/Font.hx b/lime/text/Font.hx
new file mode 100644
index 000000000..65f614781
--- /dev/null
+++ b/lime/text/Font.hx
@@ -0,0 +1,403 @@
+package lime.text;
+
+
+import lime.graphics.Image;
+import lime.graphics.ImageBuffer;
+import lime.utils.ByteArray;
+import lime.utils.UInt8Array;
+import lime.system.System;
+
+#if (js && html5)
+import js.html.CanvasElement;
+import js.html.CanvasRenderingContext2D;
+#end
+
+@:autoBuild(lime.Assets.embedFont())
+
+
+class Font {
+	
+	
+	public var fontName (default, null):String;
+	public var image:Image;
+	public var glyphs:Map<Int, Map<Int, GlyphRect>>;
+	
+	@:noCompletion private var __fontPath:String;
+	@:noCompletion private var __handle:Dynamic;
+	
+	
+	public function new (fontName:String = null) {
+		
+		this.fontName = fontName;
+		this.glyphs = new Map<Int, Map<Int, GlyphRect>> ();
+		
+	}
+	
+	
+	public function createImage ():ImageBuffer {
+		
+		glyphs = new Map<Int, Map<Int, GlyphRect>> ();
+		
+		#if (js && html5)
+		
+		/*
+		if (__canvas == null) {
+			
+			__canvas = cast js.Browser.document.createElement ("canvas");
+			__context = cast __canvas.getContext ("2d");
+			
+		}
+		
+		__canvas.width = __canvas.height = 128;
+		__context.fillStyle = "#000000";
+		__context.textBaseline = "top";
+		__context.textAlign = "left";
+		__context.font = size + "px " + fontFace;
+		
+		// canvas doesn't give the appropriate metrics so the values have to be padded...
+		var padding = size / 4;
+		
+		var x = 0.0, y = 0.0, i = 0;
+		
+		var height = size + padding;
+		
+		while (i < glyphs.length) {
+			
+			var c = glyphs.charAt(i++);
+			var metrics = __context.measureText (c);
+			var width = metrics.width + 4; // fudge because of incorrect text metrics
+			
+			if (x + width > __canvas.width) {
+				
+				y += height + 1;
+				x = 0;
+				
+			}
+			
+			if (y + height > __canvas.height) {
+				
+				if (__canvas.width < __canvas.height) {
+					
+					__canvas.width *= 2;
+					
+				} else {
+					
+					__canvas.height *= 2;
+					
+				}
+				
+				__context.clearRect (0, 0, __canvas.width, __canvas.height);
+				__context.textBaseline = "top";
+				__context.textAlign = "left";
+				__context.fillStyle = "#000000";
+				__context.font = size + "px " + fontFace;
+				
+				glyphRects = new IntMap<GlyphRect>();
+				x = y = i = 0;
+				continue;
+				
+			}
+			
+			__context.fillText (c, x + 2, y);
+			glyphRects.set(c, new GlyphRect(x, y, width, height, Std.int(width)));
+			
+			x += width;
+			
+		}
+		
+		var image = new js.html.Image ();
+		image.src = __canvas.toDataURL();
+		return new Image (image, __canvas.width, __canvas.height);*/
+		
+		#elseif flash
+		
+		/*var bd = new flash.display.BitmapData(128, 128, true, 0);
+		var tf = new flash.text.TextField ();
+		var format = new flash.text.TextFormat ();
+		format.size = size;
+		format.font = fontFace;
+		tf.defaultTextFormat = format;
+		// tf.embedFonts = true;
+		var mat = new flash.geom.Matrix ();
+		
+		var i = 0, x = 0.0, y = 0.0, maxHeight = 0.0;
+		
+		while (i < glyphs.length) {
+			
+			var c = glyphs.charAt(i++);
+			tf.text = c;
+			
+			if (x + tf.textWidth > bd.width) {
+				
+				y += maxHeight + 1;
+				x = maxHeight = 0;
+				
+			}
+			
+			if (y + tf.textHeight > bd.height) {
+				
+				if (bd.width < bd.height) {
+					
+					bd = new flash.display.BitmapData(bd.width * 2, bd.height, true, 0);
+					
+				} else {
+					
+					bd = new flash.display.BitmapData(bd.width, bd.height * 2, true, 0);
+					
+				}
+				
+				glyphRects = new IntMap<GlyphRect>();
+				x = y = maxHeight = i = 0;
+				continue;
+				
+			}
+			
+			mat.identity ();
+			mat.translate (x, y);
+			bd.draw (tf, mat);
+			
+			glyphRects.set(c, new GlyphRect (x, y, tf.textWidth + 2, tf.textHeight + 2, Std.int(tf.textWidth + 2)));
+			
+			x += tf.textWidth + 4;
+			
+			if (tf.textHeight + 4 > maxHeight) {
+				
+				maxHeight = tf.textHeight + 4;
+				
+			}
+			
+		}
+		
+		return new ImageBuffer (bd, bd.width, bd.height);*/
+		
+		#elseif (cpp || neko || nodejs)
+		
+		if (__handle == null) throw "Uninitialized font handle.";
+		var data = lime_font_create_image (__handle);
+		
+		if (data == null) {
+			
+			return null;
+			
+		} else {
+			
+			var glyphRects:Map<Int, GlyphRect>;
+			
+			for (glyph in cast (data.glyphs, Array<Dynamic>)) {
+				
+				if (glyphs.exists (glyph.size)) {
+					
+					glyphRects = glyphs.get (glyph.size);
+					
+				} else {
+					
+					glyphRects = new Map<Int, GlyphRect> ();
+					glyphs.set (glyph.size, glyphRects);
+					
+				}
+				
+				glyphRects.set (glyph.codepoint, new GlyphRect (glyph.x, glyph.y, glyph.width, glyph.height, glyph.offset.x, glyph.offset.y));
+				
+			}
+			
+			return new ImageBuffer (new UInt8Array (data.image.data), data.image.width, data.image.height, data.image.bpp);
+			
+		}
+		
+		#end
+		
+		return null;
+		
+	}
+	
+	
+	public function decompose ():NativeFontData {
+		
+		#if (cpp || neko || nodejs)
+		
+		if (__handle == null) throw "Uninitialized font handle.";
+		return lime_font_outline_decompose (__handle, 1024 * 20);
+		
+		#else
+		
+		return null;
+		
+		#end
+		
+	}
+	
+	
+	public static function fromBytes (bytes:ByteArray):Font {
+		
+		var font = new Font ();
+		font.__fromBytes (bytes);
+		return font;
+		
+	}
+	
+	
+	public static function fromFile (path:String):Font {
+		
+		var font = new Font ();
+		font.__fromFile (path);
+		return font;
+		
+	}
+	
+	
+	public function loadRange (size:Int, start:Int, end:Int) {
+		
+		#if (flash || js)
+		
+		// this.glyphs = glyphs;
+		
+		#elseif (cpp || neko || nodejs)
+		
+		if (__handle == null) throw "Uninitialized font handle.";
+		lime_font_load_range (__handle, size, start, end);
+		
+		#end
+		
+	}
+	
+	
+	public function loadGlyphs (size:Int, glyphs:String=null) {
+		
+		if (glyphs == null) {
+			
+			glyphs = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^`'\"/\\&*()[]{}<>|:;_-+=?,. ";
+			
+		}
+		
+		#if (flash || js)
+		
+		//this.glyphs = glyphs;
+		
+		#elseif (cpp || neko || nodejs)
+		
+		if (__handle == null) throw "Uninitialized font handle.";
+		lime_font_load_glyphs (__handle, size, glyphs);
+		
+		#end
+		
+	}
+	
+	
+	@:noCompletion private function __fromBytes (bytes:ByteArray):Void {
+		
+		__fontPath = null;
+		
+		#if (cpp || neko || nodejs)
+		
+		__handle = lime_font_load (bytes);
+		
+		if (__handle != null) {
+			
+			fontName = lime_font_get_family_name (__handle);
+			
+		}
+		
+		#end
+		
+	}
+	
+	
+	@:noCompletion private function __fromFile (path:String):Void {
+		
+		__fontPath = path;
+		
+		#if (cpp || neko || nodejs)
+		
+		__handle = lime_font_load (__fontPath);
+		
+		if (__handle != null) {
+			
+			fontName = lime_font_get_family_name (__handle);
+			
+		}
+		
+		#end
+		
+	}
+	
+	
+	#if (cpp || neko || nodejs)
+	private static var lime_font_get_family_name = System.load ("lime", "lime_font_get_family_name", 1);
+	private static var lime_font_load:Dynamic = System.load ("lime", "lime_font_load", 1);
+	private static var lime_font_load_glyphs = System.load ("lime", "lime_font_load_glyphs", 3);
+	private static var lime_font_load_range = System.load ("lime", "lime_font_load_range", 4);
+	private static var lime_font_create_image = System.load ("lime", "lime_font_create_image", 1);
+	private static var lime_font_outline_decompose = System.load ("lime", "lime_font_outline_decompose", 2);
+	#end
+	
+	
+}
+
+
+class GlyphRect {
+	
+	
+	public var x:Float;
+	public var y:Float;
+	public var width:Float;
+	public var height:Float;
+	public var xOffset:Int;
+	public var yOffset:Int;
+	
+	
+	public function new (x:Float, y:Float, width:Float, height:Float, xOffset:Int=0, yOffset:Int=0) {
+		
+		this.x = x;
+		this.y = y;
+		this.xOffset = xOffset;
+		this.yOffset = yOffset;
+		this.width = width;
+		this.height = height;
+		
+	}
+	
+	
+}
+
+
+typedef NativeFontData = {
+	
+	var has_kerning:Bool;
+	var is_fixed_width:Bool;
+	var has_glyph_names:Bool;
+	var is_italic:Bool;
+	var is_bold:Bool;
+	var num_glyphs:Int;
+	var family_name:String;
+	var style_name:String;
+	var em_size:Int;
+	var ascend:Int;
+	var descend:Int;
+	var height:Int;
+	var glyphs:Array<NativeGlyphData>;
+	var kerning:Array<NativeKerningData>;
+	
+}
+
+
+typedef NativeGlyphData = {
+	
+	var char_code:Int;
+	var advance:Int;
+	var min_x:Int;
+	var max_x:Int;
+	var min_y:Int;
+	var max_y:Int;
+	var points:Array<Int>;
+	
+}
+
+
+typedef NativeKerningData = {
+	
+	var left_glyph:Int;
+	var right_glyph:Int;
+	var x:Int;
+	var y:Int;
+	
+}
diff --git a/lime/text/TextDirection.hx b/lime/text/TextDirection.hx
new file mode 100644
index 000000000..1c8bdbd15
--- /dev/null
+++ b/lime/text/TextDirection.hx
@@ -0,0 +1,70 @@
+package lime.text;
+
+
+@:enum abstract TextDirection(Int) to (Int) {
+	
+	
+	var INVALID = 0;
+	var LEFT_TO_RIGHT = 4;
+	var RIGHT_TO_LEFT = 5;
+	var TOP_TO_BOTTOM = 6;
+	var BOTTOM_TO_TOP = 7;
+	
+	
+	public var backward (get, never):Bool;
+	public var forward (get, never):Bool;
+	public var horizontal (get, never):Bool;
+	public var vertical (get, never):Bool;
+	
+	
+	public inline function reverse ():Void {
+		
+		this = this ^ 1;
+		
+	}
+	
+	
+	public inline function toString ():String {
+		
+		return switch (this) {
+			
+			case LEFT_TO_RIGHT: "leftToRight";
+			case RIGHT_TO_LEFT: "rightToLeft";
+			case TOP_TO_BOTTOM: "topToBottom";
+			case BOTTOM_TO_TOP: "bottomToTop";
+			default: "";
+			
+		}
+		
+	}
+	
+	
+	private inline function get_backward ():Bool {
+		
+		return (this & ~2) == 5;
+		
+	}
+	
+	
+	private inline function get_forward ():Bool {
+		
+		return (this & ~2) == 4;
+		
+	}
+	
+	
+	private inline function get_horizontal ():Bool {
+		
+		return (this & ~1) == 4;
+		
+	}
+	
+	
+	private inline function get_vertical ():Bool {
+		
+		return (this & ~1) == 6;
+		
+	}
+	
+	
+}
\ No newline at end of file
diff --git a/lime/text/TextFormat.hx b/lime/text/TextFormat.hx
new file mode 100644
index 000000000..800bd964d
--- /dev/null
+++ b/lime/text/TextFormat.hx
@@ -0,0 +1,65 @@
+package lime.text;
+
+
+import lime.system.System;
+
+@:access(lime.text.Font)
+
+
+class TextLayout {
+	
+	
+	public var direction(default, null):TextDirection;
+	
+	#if (cpp || neko || nodejs)
+	public var handle:Dynamic;
+	#end
+	
+	
+	public function new (direction:TextDirection, script:TextScript, language:String) {
+		
+		#if (cpp || neko || nodejs)
+		handle = lime_text_create (direction, script, language);
+		#end
+		
+		this.direction = direction;
+		
+	}
+	
+	
+	public function fromString (font:Font, size:Int, text:String):Array<PosInfo> {
+		
+		#if (cpp || neko || nodejs)
+		
+		if (font.__handle == null) throw "Uninitialized font handle.";
+		return lime_text_from_string (handle, font.__handle, size, text);
+		
+		#else
+		
+		return null;
+		
+		#end
+		
+	}
+	
+	
+	#if (cpp || neko || nodejs)
+	private static var lime_text_create = System.load ("lime", "lime_text_create", 3);
+	private static var lime_text_from_string = System.load ("lime", "lime_text_from_string", 4);
+	#end
+	
+	
+}
+
+
+typedef Point = {
+	var x:Float;
+	var y:Float;
+};
+
+
+typedef PosInfo = {
+	var codepoint:UInt;
+	var advance:Point;
+	var offset:Point;
+};
\ No newline at end of file
diff --git a/lime/text/TextLayout.hx b/lime/text/TextLayout.hx
new file mode 100644
index 000000000..83a477b0d
--- /dev/null
+++ b/lime/text/TextLayout.hx
@@ -0,0 +1,75 @@
+package lime.text;
+
+
+import lime.system.System;
+
+@:access(lime.text.Font)
+
+
+class TextLayout {
+	
+	
+	public var direction (default, null):TextDirection;
+	public var language (default, null):String;
+	public var script (default, null):TextScript;
+	
+	#if (cpp || neko || nodejs)
+	private var __handle:Dynamic;
+	#end
+	
+	
+	public function new (direction:TextDirection = LEFT_TO_RIGHT, script:TextScript = COMMON, language:String = "") {
+		
+		this.direction = direction;
+		this.script = script;
+		this.language = language;
+		
+		#if (cpp || neko || nodejs)
+		__handle = lime_text_layout_create (direction, script, language);
+		#end
+		
+		this.direction = direction;
+		
+	}
+	
+	
+	public function layout (font:Font, size:Int, text:String):Array<PosInfo> {
+		
+		#if (cpp || neko || nodejs)
+		
+		if (font.__handle == null) throw "Uninitialized font handle.";
+		return lime_text_layout_layout (__handle, font.__handle, size, text);
+		
+		#else
+		
+		return null;
+		
+		#end
+		
+	}
+	
+	
+	#if (cpp || neko || nodejs)
+	private static var lime_text_layout_create = System.load ("lime", "lime_text_layout_create", 3);
+	private static var lime_text_layout_layout = System.load ("lime", "lime_text_layout_layout", 4);
+	#end
+	
+	
+}
+
+
+typedef Point = {
+	
+	var x:Float;
+	var y:Float;
+	
+};
+
+
+typedef PosInfo = {
+	
+	var codepoint:UInt;
+	var advance:Point;
+	var offset:Point;
+	
+};
\ No newline at end of file
diff --git a/lime/text/TextScript.hx b/lime/text/TextScript.hx
new file mode 100644
index 000000000..1298fc6d4
--- /dev/null
+++ b/lime/text/TextScript.hx
@@ -0,0 +1,162 @@
+package lime.text;
+
+
+@:enum abstract TextScript(String) to (String) {
+	
+	var COMMON = "Zyyy";
+	var INHERITED = "Zinh";
+	var UNKNOWN = "Zzzz";
+	
+	var ARABIC = "Arab";
+	var ARMENIAN = "Armn";
+	var BENGALI = "Beng";
+	var CYRILLIC = "Cyrl";
+	var DEVANAGARI = "Deva";
+	var GEORGIAN = "Geor";
+	var GREEK = "Grek";
+	var GUJARATI = "Gujr";
+	var GURMUKHI = "Guru";
+	var HANGUL = "Hang";
+	var HAN = "Hani";
+	var HEBREW = "Hebr";
+	var HIRAGANA = "Hira";
+	var KANNADA = "Knda";
+	var KATAKANA = "Kana";
+	var LAO = "Laoo";
+	var LATIN = "Latn";
+	var MALAYALAM = "Mlym";
+	var ORIYA = "Orya";
+	var TAMIL = "Taml";
+	var TELUGA = "Telu";
+	var THAI = "Thai";
+	
+	var TIBETAN = "Tibt";
+	
+	var BOPOMOFO = "Bopo";
+	var BRAILLE = "Brai";
+	var CANADIAN_SYLLABICS = "Cans";
+	var CHEROKEE = "Cher";
+	var ETHIOPIC = "Ethi";
+	var KHMER = "Khmr";
+	var MONGOLIAN = "Mong";
+	var MYANMAR = "Mymr";
+	var OGHAM = "Ogam";
+	var RUNIC = "Runr";
+	var SINHALA = "Sinh";
+	var SYRIAC = "Syrc";
+	var THAANA = "Thaa";
+	var YI = "Yiii";
+	
+	var DESERET = "Dsrt";
+	var GOTHIC = "Goth";
+	var OLD_ITALIC = "Ital";
+	
+	var BUHID = "Buhd";
+	var HANUNOO = "Hano";
+	var TAGALOG = "Tglg";
+	var TAGBANWA = "Tagb";
+	
+	var CYPRIOT = "Cprt";
+	var LIMBU = "Limb";
+	var LINEAR_B = "Linb";
+	var OSMANYA = "Osma";
+	var SHAVIAN = "Shaw";
+	var TAI_LE = "Tale";
+	var UGARITIC = "Ugar";
+	
+	var BUGINESE = "Bugi";
+	var COPTIC = "Copt";
+	var GLAGOLITIC = "Glag";
+	var KHAROSHTHI = "Khar";
+	var NEW_TAI_LUE = "Talu";
+	var OLD_PERSIAN = "Xpeo";
+	var SYLOTI_NAGRI = "Sylo";
+	var TIFINAGH = "Tfng";
+	
+	var BALINESE = "Bali";
+	var CUNEIFORM = "Xsux";
+	var NKO = "Nkoo";
+	var PHAGS_PA = "Phag";
+	var PHOENICIAN = "Phnx";
+	
+	var CARIAN = "Cari";
+	var CHAM = "Cham";
+	var KAYAH_LI = "Kali";
+	var LEPCHA = "Lepc";
+	var LYCIAN = "Lyci";
+	var LYDIAN = "Lydi";
+	var OL_CHIKI = "Olck";
+	var REJANG = "Rjng";
+	var SAURASHTRA = "Saur";
+	var SUNDANESE = "Sund";
+	var VAI = "Vaii";
+	
+	var AVESTAN = "Avst";
+	var BAMUM = "Bamu";
+	var EGYPTIAN_HIEROGLYPHS = "Egyp";
+	var IMPERIAL_ARAMAIC = "Armi";
+	var INSCRIPTIONAL_PAHLAVI = "Phli";
+	var INSCRIPTIONAL_PARTHIAN = "Prti";
+	var JAVANESE = "Java";
+	var KAITHI = "Kthi";
+	var LISU = "Lisu";
+	var MEETEI_MAYEK = "Mtei";
+	var OLD_SOUTH_ARABIAN = "Sarb";
+	var OLD_TURKIC = "Orkh";
+	var SAMARITAN = "Samr";
+	var TAI_THAM = "Lana";
+	var TAI_VIET = "Tavt";
+	
+	var BATAK = "Batk";
+	var BRAHMI = "Brah";
+	var MANDAIC = "Mand";
+	
+	var CHAKMA = "Cakm";
+	var MEROITIC_CURSIVE = "Merc";
+	var MEROITIC_HIEROGLYPHS = "Mero";
+	var MIAO = "Plrd";
+	var SHARADA = "Shrd";
+	var SORA_SOMPENG = "Sora";
+	var TAKRI = "Takr";
+	
+	var BASSA_VAH = "Bass";
+	var CAUCASIAN_ALBANIAN = "Aghb";
+	var DUPLOYAN = "Dupl";
+	var ELBASAN = "Elba";
+	var GRANTHA = "Gran";
+	var KHOJKI = "Khoj";
+	var KHUDAWADI = "Sind";
+	var LINEAR_A = "Lina";
+	var MAHAJANI = "Mahj";
+	var MANICHAEAN = "Mani";
+	var MENDE_KIKAKUI = "Mend";
+	var MODI = "Modi";
+	var MRO = "Mroo";
+	var NABATAEAN = "Nbat";
+	var OLD_NORTH_ARABIAN = "Narb";
+	var OLD_PERMIC = "Perm";
+	var PAHAWH_HMONG = "Hmng";
+	var PALMYRENE = "Palm";
+	var PAU_CIN_HAU = "Pauc";
+	var PSALTER_PAHLAVI = "Phlp";
+	var SIDDHAM = "Sidd";
+	var TIRHUTA = "Tirh";
+	var WARANG_CITI = "Wara";
+	
+	
+	public var rightToLeft (get, never):Bool;
+	
+	
+	private inline function get_rightToLeft ():Bool {
+		
+		return switch (this) {
+			
+			case HEBREW, ARABIC, SYRIAC, THAANA, NKO, SAMARITAN, MANDAIC, IMPERIAL_ARAMAIC, PHOENICIAN, LYDIAN, CYPRIOT, KHAROSHTHI, OLD_SOUTH_ARABIAN, AVESTAN, INSCRIPTIONAL_PAHLAVI, PSALTER_PAHLAVI, OLD_TURKIC: true;
+			//case KURDISH: true;
+			default: false;
+			
+		}
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/project/Build.xml b/project/Build.xml
index 6c845dd72..7be2f259d 100644
--- a/project/Build.xml
+++ b/project/Build.xml
@@ -59,14 +59,14 @@
 			<compilerflag value="-I${NATIVE_TOOLKIT_PATH}/freetype/include" />
 			<compilerflag value="-DLIME_FREETYPE" />
 			
-			<file name="src/graphics/Font.cpp" />
+			<file name="src/text/Font.cpp" />
 			
 			<section if="LIME_HARFBUZZ">
 				
 				<compilerflag value="-I${NATIVE_TOOLKIT_PATH}/harfbuzz/src" />
 				<compilerflag value="-DLIME_HARFBUZZ" />
 				
-				<file name="src/graphics/Text.cpp" />
+				<file name="src/text/TextLayout.cpp" />
 				
 			</section>
 			
diff --git a/project/include/graphics/Text.h b/project/include/graphics/Text.h
deleted file mode 100644
index 43f77da85..000000000
--- a/project/include/graphics/Text.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef LIME_GRAPHICS_TEXT_H
-#define LIME_GRAPHICS_TEXT_H
-
-
-#include <hx/CFFI.h>
-#include <hb.h>
-
-
-namespace lime {
-
-
-	class Font;
-
-
-	class Text {
-
-
-		public:
-
-			Text (hb_tag_t direction, const char *script, const char *language);
-			~Text ();
-
-			value FromString (Font *font, size_t size, const char *text);
-
-		private:
-
-			hb_buffer_t *mBuffer;
-			hb_direction_t mDirection;
-			hb_script_t mScript;
-			hb_language_t mLanguage;
-
-
-	};
-
-
-}
-
-
-#endif
diff --git a/project/include/graphics/Font.h b/project/include/text/Font.h
similarity index 59%
rename from project/include/graphics/Font.h
rename to project/include/text/Font.h
index 7d843a1f5..a18edb081 100644
--- a/project/include/graphics/Font.h
+++ b/project/include/text/Font.h
@@ -1,20 +1,11 @@
-#ifndef LIME_GRAPHICS_FONT_H
-#define LIME_GRAPHICS_FONT_H
+#ifndef LIME_TEXT_FONT_H
+#define LIME_TEXT_FONT_H
 
 
+#include <graphics/ImageBuffer.h>
+#include <utils/Resource.h>
 #include <hx/CFFI.h>
 #include <list>
-#include <graphics/ImageBuffer.h>
-
-#ifdef LIME_FREETYPE
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include FT_BITMAP_H
-#include FT_SFNT_NAMES_H
-#include FT_TRUETYPE_IDS_H
-#include FT_GLYPH_H
-#include FT_OUTLINE_H
-#endif
 
 
 namespace lime {
@@ -27,13 +18,8 @@ namespace lime {
 		
 		unsigned long codepoint;
 		size_t size;
-	#ifdef LIME_FREETYPE
-		FT_UInt index;
-		FT_Pos height;
-	#else
 		int index;
 		int height;
-	#endif
 		
 	} GlyphInfo;
 	
@@ -43,25 +29,22 @@ namespace lime {
 		
 		public:
 			
-			static Font *FromFile (const char *fontFace);
+			Font (void* face = 0);
+			Font (Resource *resource, int faceIndex = 0);
+			~Font ();
 			
 			value Decompose (int em);
-			value GetFamilyName ();
+			wchar_t *GetFamilyName ();
+			bool InsertCodepointFromIndex (unsigned long codepoint);
 			void LoadGlyphs (const char *glyphs);
 			void LoadRange (unsigned long start, unsigned long end);
 			value RenderToImage (ImageBuffer *image);
 			void SetSize (size_t size);
-			bool InsertCodepointFromIndex (unsigned long codepoint);
-
-			#ifdef LIME_FREETYPE
-			Font (FT_Face face);
-			FT_Face face;
-			#else
+			
 			void* face;
-			#endif
 			
 		private:
-
+			
 			bool InsertCodepoint (unsigned long codepoint, bool b = true);
 			
 			std::list<GlyphInfo> glyphList;
diff --git a/project/include/text/TextLayout.h b/project/include/text/TextLayout.h
new file mode 100644
index 000000000..7427a012a
--- /dev/null
+++ b/project/include/text/TextLayout.h
@@ -0,0 +1,35 @@
+#ifndef LIME_TEXT_TEXT_LAYOUT_H
+#define LIME_TEXT_TEXT_LAYOUT_H
+
+
+#include <text/Font.h>
+#include <hx/CFFI.h>
+
+
+namespace lime {
+	
+	
+	class TextLayout {
+		
+		
+		public:
+			
+			TextLayout (int direction, const char *script, const char *language);
+			~TextLayout ();
+			
+			value Layout (Font *font, size_t size, const char *text);
+			
+		private:
+			
+			void *mBuffer;
+			int mDirection;
+			int mScript;
+			int mLanguage;
+			
+	};
+	
+	
+}
+
+
+#endif
\ No newline at end of file
diff --git a/project/include/utils/ByteArray.h b/project/include/utils/ByteArray.h
index 06bfa7c10..03172b12c 100644
--- a/project/include/utils/ByteArray.h
+++ b/project/include/utils/ByteArray.h
@@ -35,6 +35,7 @@ namespace lime {
 		ByteArray ();
 		ByteArray (struct _value *Value);
 		ByteArray (const QuickVec<unsigned char> &inValue);
+		ByteArray (const OSChar *inFilename);
 		
 		void Resize (int inSize);
 		int Size() const;
@@ -44,7 +45,6 @@ namespace lime {
 		
 		struct _value *mValue;
 		
-		static ByteArray FromFile (const OSChar *inFilename);
 		static int ToFile (const OSChar *inFilename, const ByteArray array);
 		
 		
diff --git a/project/src/ExternalInterface.cpp b/project/src/ExternalInterface.cpp
index 695d98b7e..7c1aab6b5 100644
--- a/project/src/ExternalInterface.cpp
+++ b/project/src/ExternalInterface.cpp
@@ -15,14 +15,12 @@
 #include <audio/AudioBuffer.h>
 #include <graphics/format/JPEG.h>
 #include <graphics/format/PNG.h>
-#include <graphics/Font.h>
-#ifdef LIME_HARFBUZZ
-#include <graphics/Text.h>
-#endif
 #include <graphics/ImageBuffer.h>
 #include <graphics/Renderer.h>
 #include <graphics/RenderEvent.h>
 #include <system/System.h>
+#include <text/Font.h>
+#include <text/TextLayout.h>
 #include <ui/KeyEvent.h>
 #include <ui/Mouse.h>
 #include <ui/MouseCursor.h>
@@ -137,9 +135,9 @@ namespace lime {
 	}
 	
 	
-	void lime_font_destroy (value fontHandle) {
+	void lime_font_destroy (value handle) {
 		
-		Font *font = (Font*)(intptr_t)val_float (fontHandle);
+		Font *font = (Font*)(intptr_t)val_float (handle);
 		delete font;
 		font = 0;
 		
@@ -150,7 +148,7 @@ namespace lime {
 		
 		#ifdef LIME_FREETYPE
 		Font *font = (Font*)(intptr_t)val_float (fontHandle);
-		return font->GetFamilyName ();
+		return alloc_wstring (font->GetFamilyName ());
 		#else
 		return alloc_null ();
 		#endif
@@ -158,25 +156,35 @@ namespace lime {
 	}
 	
 	
-	value lime_font_load (value fontFace) {
+	value lime_font_load (value data) {
 		
 		#ifdef LIME_FREETYPE
-		Font *font = Font::FromFile (val_string (fontFace));
+		Resource resource;
+		
+		if (val_is_string (data)) {
+			
+			resource = Resource (val_string (data));
+			
+		} else {
+			
+			ByteArray bytes (data);
+			resource = Resource (&bytes);
+			
+		}
+		
+		Font *font = new Font (&resource, 0);
+		
 		if (font) {
-
+			
 			value v = alloc_float ((intptr_t)font);
 			val_gc (v, lime_font_destroy);
 			return v;
-
-		} else {
-
-			return alloc_null ();
-
+			
 		}
-		#else
-		return alloc_null ();
 		#endif
 		
+		return alloc_null ();
+		
 	}
 	
 	
@@ -417,10 +425,10 @@ namespace lime {
 	}
 	
 	
-	void lime_text_destroy (value textHandle) {
+	void lime_text_layout_destroy (value textHandle) {
 		
 		#ifdef LIME_HARFBUZZ
-		Text *text = (Text*)(intptr_t)val_float (textHandle);
+		TextLayout *text = (TextLayout*)(intptr_t)val_float (textHandle);
 		delete text;
 		text = 0;
 		#endif
@@ -428,28 +436,36 @@ namespace lime {
 	}
 	
 	
-	value lime_text_create (value direction, value script, value language) {
+	value lime_text_layout_create (value direction, value script, value language) {
 		
 		#if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ)
-		Text *text = new Text (val_int (direction), val_string (script), val_string (language));
+		
+		TextLayout *text = new TextLayout (val_int (direction), val_string (script), val_string (language));
 		value v = alloc_float ((intptr_t)text);
-		val_gc (v, lime_text_destroy);
+		val_gc (v, lime_text_layout_destroy);
 		return v;
+		
 		#else
+		
 		return alloc_null ();
+		
 		#endif
 		
 	}
 	
 	
-	value lime_text_from_string (value textHandle, value fontHandle, value size, value textString) {
+	value lime_text_layout_layout (value textHandle, value fontHandle, value size, value textString) {
 		
 		#if defined(LIME_FREETYPE) && defined(LIME_HARFBUZZ)
-		Text *text = (Text*)(intptr_t)val_float (textHandle);
+		
+		TextLayout *text = (TextLayout*)(intptr_t)val_float (textHandle);
 		Font *font = (Font*)(intptr_t)val_float (fontHandle);
-		return text->FromString(font, val_int (size), val_string (textString));
+		return text->Layout (font, val_int (size), val_string (textString));
+		
 		#else
+		
 		return alloc_null ();
+		
 		#endif
 		
 	}
@@ -556,8 +572,8 @@ namespace lime {
 	DEFINE_PRIM (lime_renderer_flip, 1);
 	DEFINE_PRIM (lime_render_event_manager_register, 2);
 	DEFINE_PRIM (lime_system_gettimer, 0);
-	DEFINE_PRIM (lime_text_create, 3);
-	DEFINE_PRIM (lime_text_from_string, 4);
+	DEFINE_PRIM (lime_text_layout_create, 3);
+	DEFINE_PRIM (lime_text_layout_layout, 4);
 	DEFINE_PRIM (lime_touch_event_manager_register, 2);
 	DEFINE_PRIM (lime_update_event_manager_register, 2);
 	DEFINE_PRIM (lime_window_close, 1);
@@ -575,4 +591,4 @@ extern "C" int lime_register_prims () {
 	
 	return 0;
 	
-}
+}
\ No newline at end of file
diff --git a/project/src/graphics/format/JPEG.cpp b/project/src/graphics/format/JPEG.cpp
index 56e2e1172..48cff379a 100644
--- a/project/src/graphics/format/JPEG.cpp
+++ b/project/src/graphics/format/JPEG.cpp
@@ -217,7 +217,7 @@ namespace lime {
 				
 			} else {
 				
-				ByteArray data = ByteArray::FromFile (resource->path);
+				ByteArray data = ByteArray (resource->path);
 				MySrcManager manager (data.Bytes (), data.Size ());
 				cinfo.src = &manager.pub;
 				
diff --git a/project/src/graphics/format/PNG.cpp b/project/src/graphics/format/PNG.cpp
index dd1170cae..1dd707f38 100644
--- a/project/src/graphics/format/PNG.cpp
+++ b/project/src/graphics/format/PNG.cpp
@@ -143,7 +143,7 @@ namespace lime {
 				
 			} else {
 				
-				ByteArray data = ByteArray::FromFile (resource->path);
+				ByteArray data = ByteArray (resource->path);
 				ReadBuffer buffer (data.Bytes (), data.Size ());
 				png_set_read_fn (png_ptr, &buffer, user_read_data_fn);
 				
diff --git a/project/src/graphics/Font.cpp b/project/src/text/Font.cpp
similarity index 67%
rename from project/src/graphics/Font.cpp
rename to project/src/text/Font.cpp
index e00112e5c..5e78d50b1 100644
--- a/project/src/graphics/Font.cpp
+++ b/project/src/text/Font.cpp
@@ -1,11 +1,25 @@
-#include <graphics/Font.h>
+#include <text/Font.h>
 #include <graphics/ImageBuffer.h>
+#include <system/System.h>
+
 #include <algorithm>
 #include <vector>
 
+#ifdef LIME_FREETYPE
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_BITMAP_H
+#include FT_SFNT_NAMES_H
+#include FT_TRUETYPE_IDS_H
+#include FT_GLYPH_H
+#include FT_OUTLINE_H
+#endif
+
+
 // from http://stackoverflow.com/questions/2948308/how-do-i-read-utf-8-characters-via-a-pointer
 #define IS_IN_RANGE(c, f, l)	 (((c) >= (f)) && ((c) <= (l)))
 
+
 unsigned long readNextChar (char*& p)
 {
 	 // TODO: since UTF-8 is a variable-length
@@ -259,63 +273,31 @@ namespace lime {
 	}
 	
 	
-	Font *Font::FromFile (const char *fontFace) {
+	Font::Font (void* face) {
 		
-		int error;
-		FT_Library library;
-		
-		error = FT_Init_FreeType (&library);
-		
-		if (error) {
-			
-			printf ("Could not initialize FreeType\n");
-			
-		} else {
-		
-			FT_Face face;
-			error = FT_New_Face (library, fontFace, 0, &face);
-			
-			if (error == FT_Err_Unknown_File_Format) {
-
-				printf ("Invalid font type\n");
-
-			} else if (error) {
-
-				printf ("Failed to load font face %s\n", fontFace);
-
-			} else {
-
-				return new Font(face);
-
-			}
-
-		}
-		
-		return 0;
-
-	}
-
-	Font::Font (FT_Face face) {
-
 		this->face = face;
-
-		/* Set charmap
-		 *
-		 * See http://www.microsoft.com/typography/otspec/name.htm for a list of
-		 * some possible platform-encoding pairs.  We're interested in 0-3 aka 3-1
-		 * - UCS-2.  Otherwise, fail. If a font has some unicode map, but lacks
-		 * UCS-2 - it is a broken or irrelevant font. What exactly Freetype will
-		 * select on face load (it promises most wide unicode, and if that will be
-		 * slower that UCS-2 - left as an excercise to check.
-		 */
-		for (int i = 0; i < face->num_charmaps; i++) {
+		
+		if (face) {
 			
-			FT_UShort pid = face->charmaps[i]->platform_id;
-			FT_UShort eid = face->charmaps[i]->encoding_id;
-			
-			if (((pid == 0) && (eid == 3)) || ((pid == 3) && (eid == 1))) {
+			/* Set charmap
+			 *
+			 * See http://www.microsoft.com/typography/otspec/name.htm for a list of
+			 * some possible platform-encoding pairs.  We're interested in 0-3 aka 3-1
+			 * - UCS-2.  Otherwise, fail. If a font has some unicode map, but lacks
+			 * UCS-2 - it is a broken or irrelevant font. What exactly Freetype will
+			 * select on face load (it promises most wide unicode, and if that will be
+			 * slower that UCS-2 - left as an excercise to check.
+			 */
+			for (int i = 0; i < ((FT_Face)face)->num_charmaps; i++) {
 				
-				FT_Set_Charmap (face, face->charmaps[i]);
+				FT_UShort pid = ((FT_Face)face)->charmaps[i]->platform_id;
+				FT_UShort eid = ((FT_Face)face)->charmaps[i]->encoding_id;
+				
+				if (((pid == 0) && (eid == 3)) || ((pid == 3) && (eid == 1))) {
+					
+					FT_Set_Charmap ((FT_Face)face, ((FT_Face)face)->charmaps[i]);
+					
+				}
 				
 			}
 			
@@ -324,44 +306,87 @@ namespace lime {
 	}
 	
 	
-	wchar_t *get_familyname_from_sfnt_name (FT_Face face) {
+	Font::Font (Resource *resource, int faceIndex) {
 		
-		wchar_t *family_name = NULL;
-		FT_SfntName sfnt_name;
-		FT_UInt num_sfnt_names, sfnt_name_index;
-		int len, i;
-		
-		if (FT_IS_SFNT (face)) {
+		if (resource) {
 			
-			num_sfnt_names = FT_Get_Sfnt_Name_Count (face);
-			sfnt_name_index = 0;
+			int error;
+			FT_Library library;
 			
-			while (sfnt_name_index < num_sfnt_names) {
+			error = FT_Init_FreeType (&library);
+			
+			if (error) {
 				
-				if (!FT_Get_Sfnt_Name (face, sfnt_name_index++, (FT_SfntName *)&sfnt_name) && sfnt_name.name_id == TT_NAME_ID_FULL_NAME) {
+				printf ("Could not initialize FreeType\n");
+				
+			} else {
+				
+				FT_Face face;
+				FILE_HANDLE *file = NULL;
+				
+				if (resource->path) {
 					
-					if (sfnt_name.platform_id == TT_PLATFORM_MACINTOSH) {
+					file = lime::fopen (resource->path, "rb");
+					
+					if (file->isFile ()) {
 						
-						len = sfnt_name.string_len;
-						family_name = new wchar_t[len + 1];
-						mbstowcs (&family_name[0], &reinterpret_cast<const char*>(sfnt_name.string)[0], len);
-						family_name[len] = L'\0';
-						return family_name;
+						error = FT_New_Face (library, resource->path, faceIndex, &face);
 						
-					} else if ((sfnt_name.platform_id == TT_PLATFORM_MICROSOFT) && (sfnt_name.encoding_id == TT_MS_ID_UNICODE_CS)) {
+					} else {
 						
-						len = sfnt_name.string_len / 2;
-						family_name = (wchar_t*)malloc ((len + 1) * sizeof (wchar_t));
+						ByteArray data = ByteArray (resource->path);
+						unsigned char *buffer = (unsigned char*)malloc (data.Size ());
+						memcpy (buffer, data.Bytes (), data.Size ());
+						error = FT_New_Memory_Face (library, buffer, data.Size (), faceIndex, &face);
 						
-						for (i = 0; i < len; i++) {
+					}
+					
+				} else {
+					
+					unsigned char *buffer = (unsigned char*)malloc (resource->data->Size ());
+					memcpy (buffer, resource->data->Bytes (), resource->data->Size ());
+					error = FT_New_Memory_Face (library, buffer, resource->data->Size (), faceIndex, &face);
+					
+				}
+				
+				if (file) {
+					
+					lime::fclose (file);
+					
+				}
+				
+				if (error == FT_Err_Unknown_File_Format) {
+					
+					printf ("Invalid font type\n");
+					
+				} else if (error) {
+					
+					printf ("Failed to load font face %s\n", resource->path);
+					
+				} else {
+					
+					this->face = face;
+					
+					/* Set charmap
+					 *
+					 * See http://www.microsoft.com/typography/otspec/name.htm for a list of
+					 * some possible platform-encoding pairs.  We're interested in 0-3 aka 3-1
+					 * - UCS-2.  Otherwise, fail. If a font has some unicode map, but lacks
+					 * UCS-2 - it is a broken or irrelevant font. What exactly Freetype will
+					 * select on face load (it promises most wide unicode, and if that will be
+					 * slower that UCS-2 - left as an excercise to check.
+					 */
+					for (int i = 0; i < ((FT_Face)face)->num_charmaps; i++) {
+						
+						FT_UShort pid = ((FT_Face)face)->charmaps[i]->platform_id;
+						FT_UShort eid = ((FT_Face)face)->charmaps[i]->encoding_id;
+						
+						if (((pid == 0) && (eid == 3)) || ((pid == 3) && (eid == 1))) {
 							
-							family_name[i] = ((wchar_t)sfnt_name.string[i * 2 + 1]) | (((wchar_t)sfnt_name.string[i * 2]) << 8);
+							FT_Set_Charmap ((FT_Face)face, ((FT_Face)face)->charmaps[i]);
 							
 						}
 						
-						family_name[len] = L'\0';
-						return family_name;
-						
 					}
 					
 				}
@@ -370,7 +395,16 @@ namespace lime {
 			
 		}
 		
-		return NULL;
+	}
+	
+	
+	Font::~Font () {
+		
+		if (face) {
+			
+			FT_Done_Face ((FT_Face)face);
+			
+		}
 		
 	}
 	
@@ -379,7 +413,7 @@ namespace lime {
 		
 		int result, i, j;
 		
-		FT_Set_Char_Size (face, em, em, 72, 72);
+		FT_Set_Char_Size ((FT_Face)face, em, em, 72, 72);
 		
 		std::vector<glyph*> glyphs;
 		
@@ -397,20 +431,20 @@ namespace lime {
 		FT_ULong char_code;
 		FT_UInt glyph_index;
 		
-		char_code = FT_Get_First_Char (face, &glyph_index);
+		char_code = FT_Get_First_Char ((FT_Face)(FT_Face)face, &glyph_index);
 		
 		while (glyph_index != 0) {
 			
-			if (FT_Load_Glyph (face, glyph_index, FT_LOAD_NO_BITMAP | FT_LOAD_FORCE_AUTOHINT | FT_LOAD_DEFAULT) == 0) {
+			if (FT_Load_Glyph ((FT_Face)(FT_Face)face, glyph_index, FT_LOAD_NO_BITMAP | FT_LOAD_FORCE_AUTOHINT | FT_LOAD_DEFAULT) == 0) {
 				
 				glyph *g = new glyph;
-				result = FT_Outline_Decompose (&face->glyph->outline, &ofn, g);
+				result = FT_Outline_Decompose (&((FT_Face)face)->glyph->outline, &ofn, g);
 				
 				if (result == 0) {
 					
 					g->index = glyph_index;
 					g->char_code = char_code;
-					g->metrics = face->glyph->metrics;
+					g->metrics = ((FT_Face)face)->glyph->metrics;
 					glyphs.push_back (g);
 					
 				} else {
@@ -421,7 +455,7 @@ namespace lime {
 				
 			}
 			
-			char_code = FT_Get_Next_Char (face, char_code, &glyph_index);
+			char_code = FT_Get_Next_Char ((FT_Face)face, char_code, &glyph_index);
 			
 		}
 		
@@ -429,7 +463,7 @@ namespace lime {
 		std::sort (glyphs.begin (), glyphs.end (), glyph_sort_predicate ());
 		
 		std::vector<kerning>  kern;
-		if (FT_HAS_KERNING (face)) {
+		if (FT_HAS_KERNING (((FT_Face)face))) {
 			
 			int n = glyphs.size ();
 			FT_Vector v;
@@ -442,7 +476,7 @@ namespace lime {
 					
 					int r_glyph = glyphs[j]->index;
 					
-					FT_Get_Kerning (face, l_glyph, r_glyph, FT_KERNING_DEFAULT, &v);
+					FT_Get_Kerning ((FT_Face)face, l_glyph, r_glyph, FT_KERNING_DEFAULT, &v);
 					
 					if (v.x != 0 || v.y != 0) {
 						
@@ -457,21 +491,23 @@ namespace lime {
 		}
 		
 		int num_glyphs = glyphs.size ();
-		wchar_t* family_name = get_familyname_from_sfnt_name (face);
+		
+		Font font = Font (face);
+		wchar_t* family_name = font.GetFamilyName ();
 		
 		value ret = alloc_empty_object ();
-		alloc_field (ret, val_id ("has_kerning"), alloc_bool (FT_HAS_KERNING (face)));
-		alloc_field (ret, val_id ("is_fixed_width"), alloc_bool (FT_IS_FIXED_WIDTH (face)));
-		alloc_field (ret, val_id ("has_glyph_names"), alloc_bool (FT_HAS_GLYPH_NAMES (face)));
-		alloc_field (ret, val_id ("is_italic"), alloc_bool (face->style_flags & FT_STYLE_FLAG_ITALIC));
-		alloc_field (ret, val_id ("is_bold"), alloc_bool (face->style_flags & FT_STYLE_FLAG_BOLD));
+		alloc_field (ret, val_id ("has_kerning"), alloc_bool (FT_HAS_KERNING (((FT_Face)face))));
+		alloc_field (ret, val_id ("is_fixed_width"), alloc_bool (FT_IS_FIXED_WIDTH (((FT_Face)face))));
+		alloc_field (ret, val_id ("has_glyph_names"), alloc_bool (FT_HAS_GLYPH_NAMES (((FT_Face)face))));
+		alloc_field (ret, val_id ("is_italic"), alloc_bool (((FT_Face)face)->style_flags & FT_STYLE_FLAG_ITALIC));
+		alloc_field (ret, val_id ("is_bold"), alloc_bool (((FT_Face)face)->style_flags & FT_STYLE_FLAG_BOLD));
 		alloc_field (ret, val_id ("num_glyphs"), alloc_int (num_glyphs));
-		alloc_field (ret, val_id ("family_name"), family_name == NULL ? alloc_string (face->family_name) : alloc_wstring (family_name));
-		alloc_field (ret, val_id ("style_name"), alloc_string (face->style_name));
-		alloc_field (ret, val_id ("em_size"), alloc_int (face->units_per_EM));
-		alloc_field (ret, val_id ("ascend"), alloc_int (face->ascender));
-		alloc_field (ret, val_id ("descend"), alloc_int (face->descender));
-		alloc_field (ret, val_id ("height"), alloc_int (face->height));
+		alloc_field (ret, val_id ("family_name"), family_name == NULL ? alloc_string (((FT_Face)face)->family_name) : alloc_wstring (family_name));
+		alloc_field (ret, val_id ("style_name"), alloc_string (((FT_Face)face)->style_name));
+		alloc_field (ret, val_id ("em_size"), alloc_int (((FT_Face)face)->units_per_EM));
+		alloc_field (ret, val_id ("ascend"), alloc_int (((FT_Face)face)->ascender));
+		alloc_field (ret, val_id ("descend"), alloc_int (((FT_Face)face)->descender));
+		alloc_field (ret, val_id ("height"), alloc_int (((FT_Face)face)->height));
 		
 		delete family_name;
 		
@@ -507,7 +543,7 @@ namespace lime {
 		alloc_field (ret, val_id ("glyphs"), neko_glyphs);
 		
 		// 'kerning' field
-		if (FT_HAS_KERNING (face)) {
+		if (FT_HAS_KERNING (((FT_Face)face))) {
 			
 			value neko_kerning = alloc_array (kern.size ());
 			
@@ -537,17 +573,62 @@ namespace lime {
 	}
 	
 	
-	value Font::GetFamilyName () {
+	wchar_t *Font::GetFamilyName () {
 		
-		return alloc_wstring (get_familyname_from_sfnt_name (face));
+		#ifdef LIME_FREETYPE
+		
+		wchar_t *family_name = NULL;
+		FT_SfntName sfnt_name;
+		FT_UInt num_sfnt_names, sfnt_name_index;
+		int len, i;
+		
+		if (FT_IS_SFNT (((FT_Face)face))) {
+			
+			num_sfnt_names = FT_Get_Sfnt_Name_Count ((FT_Face)face);
+			sfnt_name_index = 0;
+			
+			while (sfnt_name_index < num_sfnt_names) {
+				
+				if (!FT_Get_Sfnt_Name ((FT_Face)face, sfnt_name_index++, (FT_SfntName *)&sfnt_name) && sfnt_name.name_id == TT_NAME_ID_FULL_NAME) {
+					
+					if (sfnt_name.platform_id == TT_PLATFORM_MACINTOSH) {
+						
+						len = sfnt_name.string_len;
+						family_name = new wchar_t[len + 1];
+						mbstowcs (&family_name[0], &reinterpret_cast<const char*>(sfnt_name.string)[0], len);
+						family_name[len] = L'\0';
+						return family_name;
+						
+					} else if ((sfnt_name.platform_id == TT_PLATFORM_MICROSOFT) && (sfnt_name.encoding_id == TT_MS_ID_UNICODE_CS)) {
+						
+						len = sfnt_name.string_len / 2;
+						family_name = (wchar_t*)malloc ((len + 1) * sizeof (wchar_t));
+						
+						for (i = 0; i < len; i++) {
+							
+							family_name[i] = ((wchar_t)sfnt_name.string[i * 2 + 1]) | (((wchar_t)sfnt_name.string[i * 2]) << 8);
+							
+						}
+						
+						family_name[len] = L'\0';
+						return family_name;
+						
+					}
+					
+				}
+				
+			}
+			
+		}
+		
+		#endif
+		
+		return NULL;
 		
 	}
 	
-	bool Font::InsertCodepointFromIndex (unsigned long codepoint) {
-		return InsertCodepoint(codepoint, false);
-	}
-
-	bool Font::InsertCodepoint (unsigned long codepoint, bool b) {
+	
+	bool Font::InsertCodepoint (unsigned long codepoint, bool fromIndex) {
 		
 		GlyphInfo info;
 		info.codepoint = codepoint;
@@ -561,14 +642,18 @@ namespace lime {
 		// if (codepoint < (*first).codepoint ||
 		// 	(codepoint == (*first).codepoint && mSize != (*first).size)) {
 			
-			
-			if (b) {
-				info.index = FT_Get_Char_Index (face, codepoint);
+			if (fromIndex) {
+				
+				info.index = FT_Get_Char_Index ((FT_Face)face, codepoint);
+				
 			} else {
-				info.index = codepoint;	
+				
+				info.index = codepoint;
+				
 			}
-			if (FT_Load_Glyph (face, info.index, FT_LOAD_DEFAULT) != 0) return false;
-			info.height = face->glyph->metrics.height;
+			
+			if (FT_Load_Glyph ((FT_Face)face, info.index, FT_LOAD_DEFAULT) != 0) return false;
+			info.height = ((FT_Face)face)->glyph->metrics.height;
 			
 			glyphList.insert (first, info);
 			
@@ -576,7 +661,14 @@ namespace lime {
 			
 		// }
 		
-		return false;
+		//return false;
+		
+	}
+	
+	
+	bool Font::InsertCodepointFromIndex (unsigned long codepoint) {
+		
+		return InsertCodepoint (codepoint, false);
 		
 	}
 	
@@ -617,8 +709,8 @@ namespace lime {
 			(int)((1.0) * 0x10000L)
 		};
 		
-		FT_Set_Char_Size (face, 0, (int)(size*64), (int)(hdpi * hres), vdpi);
-		FT_Set_Transform (face, &matrix, NULL);
+		FT_Set_Char_Size ((FT_Face)face, 0, (int)(size*64), (int)(hdpi * hres), vdpi);
+		FT_Set_Transform ((FT_Face)face, &matrix, NULL);
 		
 		mSize = size;
 		
@@ -662,14 +754,14 @@ namespace lime {
 		for (std::list<GlyphInfo>::iterator it = glyphList.begin (); it != glyphList.end (); it++) {
 			
 			// recalculate the character size for each glyph since it will vary
-			FT_Set_Char_Size (face, 0, (int)((*it).size*64), (int)(hdpi * hres), vdpi);
-			FT_Set_Transform (face, &matrix, NULL);
+			FT_Set_Char_Size ((FT_Face)face, 0, (int)((*it).size*64), (int)(hdpi * hres), vdpi);
+			FT_Set_Transform ((FT_Face)face, &matrix, NULL);
 			
-			FT_Load_Glyph (face, (*it).index, FT_LOAD_DEFAULT);
+			FT_Load_Glyph ((FT_Face)face, (*it).index, FT_LOAD_DEFAULT);
 			
-			if (FT_Render_Glyph (face->glyph, FT_RENDER_MODE_NORMAL) != 0) continue;
+			if (FT_Render_Glyph (((FT_Face)face)->glyph, FT_RENDER_MODE_NORMAL) != 0) continue;
 			
-			FT_Bitmap bitmap = face->glyph->bitmap;
+			FT_Bitmap bitmap = ((FT_Face)face)->glyph->bitmap;
 			
 			if (x + bitmap.width > image->width) {
 				
@@ -733,8 +825,8 @@ namespace lime {
 			alloc_field (v, id_height, alloc_int (bitmap.rows));
 			
 			value offset = alloc_empty_object ();
-			alloc_field (offset, id_x, alloc_int (face->glyph->bitmap_left));
-			alloc_field (offset, id_y, alloc_int (face->glyph->bitmap_top));
+			alloc_field (offset, id_x, alloc_int (((FT_Face)face)->glyph->bitmap_left));
+			alloc_field (offset, id_y, alloc_int (((FT_Face)face)->glyph->bitmap_top));
 			alloc_field (v, id_offset, offset);
 			
 			alloc_field (v, id_codepoint, alloc_int ((*it).index));
diff --git a/project/src/graphics/Text.cpp b/project/src/text/TextLayout.cpp
similarity index 50%
rename from project/src/graphics/Text.cpp
rename to project/src/text/TextLayout.cpp
index ab8120441..3ca9fe230 100644
--- a/project/src/graphics/Text.cpp
+++ b/project/src/text/TextLayout.cpp
@@ -1,82 +1,87 @@
-#include <graphics/Font.h>
-#include <graphics/Text.h>
+#include <text/TextLayout.h>
+
 #include <ft2build.h>
 #include FT_FREETYPE_H
 #include <hb-ft.h>
+#include <hb.h>
 
 
 namespace lime {
-
-	Text::Text (hb_tag_t direction, const char *script, const char *language) {
-
-		if (strlen(script) != 4) return;
-
+	
+	
+	TextLayout::TextLayout (int direction, const char *script, const char *language) {
+		
+		if (strlen (script) != 4) return;
+		
 		mDirection = (hb_direction_t)direction;
-		mLanguage = hb_language_from_string (language, strlen (language));
+		mLanguage = (int)hb_language_from_string (language, strlen (language));
 		mScript = hb_script_from_string (script, -1);
-
+		
 		mBuffer = hb_buffer_create ();
-		hb_buffer_set_direction (mBuffer, mDirection);
-		hb_buffer_set_script (mBuffer, mScript);
-		hb_buffer_set_language (mBuffer, mLanguage);
-
+		hb_buffer_set_direction ((hb_buffer_t*)mBuffer, (hb_direction_t)mDirection);
+		hb_buffer_set_script ((hb_buffer_t*)mBuffer, (hb_script_t)mScript);
+		hb_buffer_set_language ((hb_buffer_t*)mBuffer, (hb_language_t)mLanguage);
+		
 	}
-
-	Text::~Text () {
-
-		hb_buffer_destroy (mBuffer);
-
+	
+	
+	TextLayout::~TextLayout () {
+		
+		hb_buffer_destroy ((hb_buffer_t*)mBuffer);
+		
 	}
-
-	value Text::FromString (Font *font, size_t size, const char *text) {
-
+	
+	
+	value TextLayout::Layout (Font *font, size_t size, const char *text) {
+		
 		font->SetSize (size);
-
+		
 		// reset buffer
-		hb_buffer_reset (mBuffer);
-		hb_buffer_set_direction (mBuffer, mDirection);
-		hb_buffer_set_script (mBuffer, mScript);
-		hb_buffer_set_language (mBuffer, mLanguage);
-
+		hb_buffer_reset ((hb_buffer_t*)mBuffer);
+		hb_buffer_set_direction ((hb_buffer_t*)mBuffer, (hb_direction_t)mDirection);
+		hb_buffer_set_script ((hb_buffer_t*)mBuffer, (hb_script_t)mScript);
+		hb_buffer_set_language ((hb_buffer_t*)mBuffer, (hb_language_t)mLanguage);
+		
 		// layout the text
-		hb_buffer_add_utf8 (mBuffer, text, strlen (text), 0, -1);
-		hb_font_t *hb_font = hb_ft_font_create (font->face, NULL);
-		hb_shape (hb_font, mBuffer, NULL, 0);
-
+		hb_buffer_add_utf8 ((hb_buffer_t*)mBuffer, text, strlen (text), 0, -1);
+		hb_font_t *hb_font = hb_ft_font_create ((FT_Face)font->face, NULL);
+		hb_shape (hb_font, (hb_buffer_t*)mBuffer, NULL, 0);
+		
 		unsigned int glyph_count;
-		hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos (mBuffer, &glyph_count);
-		hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions (mBuffer, &glyph_count);
-
+		hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos ((hb_buffer_t*)mBuffer, &glyph_count);
+		hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions ((hb_buffer_t*)mBuffer, &glyph_count);
+		
 		float hres = 100;
 		value pos_info = alloc_array (glyph_count);
 		int posIndex = 0;
-
+		
 		for (int i = 0; i < glyph_count; i++) {
-
+			
 			font->InsertCodepointFromIndex(glyph_info[i].codepoint);
 			hb_glyph_position_t pos = glyph_pos[i];
-
+			
 			value obj = alloc_empty_object ();
 			alloc_field (obj, val_id ("codepoint"), alloc_float (glyph_info[i].codepoint));
-
+			
 			value advance = alloc_empty_object ();
 			alloc_field (advance, val_id ("x"), alloc_float (pos.x_advance / (float)(hres * 64)));
 			alloc_field (advance, val_id ("y"), alloc_float (pos.y_advance / (float)64));
 			alloc_field (obj, val_id ("advance"), advance);
-
+			
 			value offset = alloc_empty_object ();
 			alloc_field (offset, val_id ("x"), alloc_float (pos.x_offset / (float)(hres * 64)));
 			alloc_field (offset, val_id ("y"), alloc_float (pos.y_offset / (float)64));
 			alloc_field (obj, val_id ("offset"), offset);
-
+			
 			val_array_set_i (pos_info, posIndex++, obj);
-
+			
 		}
-
+		
 		hb_font_destroy (hb_font);
-
+		
 		return pos_info;
-
+		
 	}
-
-}
+	
+	
+}
\ No newline at end of file
diff --git a/project/src/utils/ByteArray.cpp b/project/src/utils/ByteArray.cpp
index acf209fd5..231fe27de 100644
--- a/project/src/utils/ByteArray.cpp
+++ b/project/src/utils/ByteArray.cpp
@@ -5,189 +5,201 @@
 
 
 namespace lime {
-
-
-	// --- ByteArray -----------------------------------------------------
-
+	
+	
 	AutoGCRoot *gByteArrayCreate = 0;
 	AutoGCRoot *gByteArrayLen = 0;
 	AutoGCRoot *gByteArrayResize = 0;
 	AutoGCRoot *gByteArrayBytes = 0;
-
-	value lime_byte_array_init(value inFactory, value inLen, value inResize, value inBytes) {
-
-		gByteArrayCreate = new AutoGCRoot(inFactory);
-		gByteArrayLen = new AutoGCRoot(inLen);
-		gByteArrayResize = new AutoGCRoot(inResize);
-		gByteArrayBytes = new AutoGCRoot(inBytes);
-
-		return alloc_null();
-
-	} DEFINE_PRIM(lime_byte_array_init,4);
-
-
-	ByteArray::ByteArray(int inSize)
-	{
-	   mValue = val_call1(gByteArrayCreate->get(), alloc_int(inSize) );
+	
+	
+	ByteArray::ByteArray (int inSize) {
+		
+		mValue = val_call1 (gByteArrayCreate->get (), alloc_int (inSize));
+		
 	}
-
-	ByteArray::ByteArray() : mValue(0) { }
-
-	ByteArray::ByteArray(const QuickVec<uint8> &inData)
-	{
-	   mValue = val_call1(gByteArrayCreate->get(), alloc_int(inData.size()) );
-	   uint8 *bytes = Bytes();
-	   if (bytes)
-		 memcpy(bytes, &inData[0], inData.size() );
+	
+	
+	ByteArray::ByteArray () : mValue(0) {
+		
+		
+		
 	}
-
-	ByteArray::ByteArray(const ByteArray &inRHS) : mValue(inRHS.mValue) { }
-
-	ByteArray::ByteArray(value inValue) : mValue(inValue) { }
-
-	void ByteArray::Resize(int inSize)
-	{
+	
+	
+	ByteArray::ByteArray (const QuickVec<uint8> &inData) {
+		
+		mValue = val_call1 (gByteArrayCreate->get (), alloc_int (inData.size ()));
+		uint8 *bytes = Bytes ();
+		if (bytes)
+			memcpy (bytes, &inData[0], inData.size ());
+		
+	}
+	
+	
+	ByteArray::ByteArray (const ByteArray &inRHS) : mValue (inRHS.mValue) {
+		
+		
+		
+	}
+	
+	
+	ByteArray::ByteArray (value inValue) : mValue (inValue) {
+		
+		
+		
+	}
+	
+	
+	ByteArray::ByteArray (const OSChar *inFilename) {
+		
+		FILE_HANDLE *file = lime::fopen (inFilename, "rb");
+		
+		if (!file) {
+			
+			//#ifdef ANDROID
+			//return AndroidGetAssetBytes(inFilename);
+			//#endif
+			return;
+			
+		}
+		
+		lime::fseek (file, 0, SEEK_END);
+		int len = lime::ftell (file);
+		lime::fseek (file, 0, SEEK_SET);
+		
+		mValue = val_call1 (gByteArrayCreate->get (), alloc_int (len));
+		
+		int status = lime::fread (Bytes (), len, 1, file);
+		lime::fclose (file);
+		
+	}
+	
+	
+	void ByteArray::Resize (int inSize) {
+		
 		if (mValue == 0)
-			mValue = val_call1(gByteArrayCreate->get(), alloc_int(inSize) );
+			mValue = val_call1 (gByteArrayCreate->get (), alloc_int (inSize));
 		else
-	   val_call2(gByteArrayResize->get(), mValue, alloc_int(inSize) );
-	}
-
-	int ByteArray::Size() const
-	{
-	   return val_int( val_call1(gByteArrayLen->get(), mValue ));
-	}
-
-
-	const unsigned char *ByteArray::Bytes() const
-	{
-	   value bytes = val_call1(gByteArrayBytes->get(),mValue);
-	   if (val_is_string(bytes))
-		  return (unsigned char *)val_string(bytes);
-	   buffer buf = val_to_buffer(bytes);
-	   if (buf==0)
-	   {
-		  val_throw(alloc_string("Bad ByteArray"));
-	   }
-	   return (unsigned char *)buffer_data(buf);
-	}
-
-
-	unsigned char *ByteArray::Bytes()
-	{
-	   value bytes = val_call1(gByteArrayBytes->get(),mValue);
-	   if (val_is_string(bytes))
-		  return (unsigned char *)val_string(bytes);
-	   buffer buf = val_to_buffer(bytes);
-	   if (buf==0)
-	   {
-		  val_throw(alloc_string("Bad ByteArray"));
-	   }
-	   return (unsigned char *)buffer_data(buf);
-	}
-	
-	
-	// Put in asset stubs for now, until we have a final system in place
-	
-	#ifdef ANDROID
-	FileInfo AndroidGetAssetFD(const char *inResource)
-	{
-		FileInfo info;
-		info.fd = 0;
-		info.offset = 0;
-		info.length = 0;
-		
-		// TODO
-		
-		return info;
+			val_call2 (gByteArrayResize->get (), mValue, alloc_int (inSize));
 		
 	}
 	
 	
-	ByteArray AndroidGetAssetBytes(const char *inResource) {
+	int ByteArray::Size () const {
 		
-		ByteArray result;
-		
-		// TODO
-		
-		return result;
+		return val_int (val_call1 (gByteArrayLen->get (), mValue));
 		
 	}
-	#endif
 	
-
-
-    value lime_byte_array_read_file(value inFilename) {
-
-        ByteArray result = ByteArray::FromFile(val_os_string(inFilename));
-
-        return result.mValue;
-
-    } DEFINE_PRIM(lime_byte_array_read_file,1);
-
-
-    value lime_byte_array_get_native_pointer(value inByteArray) {
-
-        ByteArray bytes(inByteArray);
-
-        if (!val_is_null (bytes.mValue)) {
-            return alloc_int((intptr_t)bytes.Bytes ());
-        }
-
-        return alloc_null();
-
-    } DEFINE_PRIM(lime_byte_array_get_native_pointer,1);
-    
-    
-    
-    
-    ByteArray ByteArray::FromFile(const OSChar *inFilename)
-{
-   FILE_HANDLE *file = lime::fopen (inFilename, "rb");
-   if (!file)
-   {
-      #ifdef ANDROID
-      return AndroidGetAssetBytes(inFilename);
-      #endif
-      return ByteArray();
-   }
-
-   lime::fseek(file,0,SEEK_END);
-   int len = lime::ftell(file);
-   lime::fseek(file,0,SEEK_SET);
-
-   ByteArray result(len);
-   int status = lime::fread(result.Bytes(),len,1,file);
-   lime::fclose(file);
-
-   return result;
-}
-
-
-value lime_byte_array_overwrite_file(value inFilename, value inBytes) {
-
-        // file is created if it doesn't exist,
-   // if it exists, it is truncated to zero
-   FILE_HANDLE *file = lime::fopen (val_os_string(inFilename), "wb");
-   if (!file)
-   {
-      #ifdef ANDROID
-      // [todo]
-      #endif
-      return alloc_null();
-   }
-
-   ByteArray array(inBytes);
-
-   // The function fwrite() writes nitems objects, each size bytes long, to the
-   // stream pointed to by stream, obtaining them from the location given by
-   // ptr.
-   // fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
-   lime::fwrite( array.Bytes() , 1, array.Size() , file);
-
-   lime::fclose(file);
-   return alloc_null();
-
-    } DEFINE_PRIM(lime_byte_array_overwrite_file, 2);
-
+	
+	const unsigned char *ByteArray::Bytes () const {
+		
+		value bytes = val_call1 (gByteArrayBytes->get (), mValue);
+		
+		if (val_is_string (bytes))
+			return (unsigned char *)val_string (bytes);
+		
+		buffer buf = val_to_buffer (bytes);
+		
+		if (buf == 0) {
+			
+			val_throw (alloc_string ("Bad ByteArray"));
+		}
+		
+		return (unsigned char *)buffer_data (buf);
+		
+	}
+	
+	
+	unsigned char *ByteArray::Bytes () {
+		
+		value bytes = val_call1 (gByteArrayBytes->get (),mValue);
+		
+		if (val_is_string (bytes))
+			return (unsigned char *)val_string (bytes);
+		
+		buffer buf = val_to_buffer (bytes);
+		
+		if (buf == 0) {
+			
+			val_throw (alloc_string ("Bad ByteArray"));
+			
+		}
+		
+		return (unsigned char *)buffer_data (buf);
+		
+	}
+	
+	
+	value lime_byte_array_get_native_pointer (value inByteArray) {
+		
+		ByteArray bytes (inByteArray);
+		
+		if (!val_is_null (bytes.mValue)) {
+			
+			return alloc_int ((intptr_t)bytes.Bytes ());
+			
+		}
+		
+		return alloc_null ();
+		
+	}
+	
+	value lime_byte_array_init (value inFactory, value inLen, value inResize, value inBytes) {
+		
+		gByteArrayCreate = new AutoGCRoot (inFactory);
+		gByteArrayLen = new AutoGCRoot (inLen);
+		gByteArrayResize = new AutoGCRoot (inResize);
+		gByteArrayBytes = new AutoGCRoot (inBytes);
+		
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_byte_array_overwrite_file (value inFilename, value inBytes) {
+		
+		// file is created if it doesn't exist,
+		// if it exists, it is truncated to zero
+		FILE_HANDLE *file = lime::fopen (val_os_string (inFilename), "wb");
+		
+		if (!file) {
+			
+			#ifdef ANDROID
+			// [todo]
+			#endif
+			return alloc_null();
+			
+		}
+		
+		ByteArray array (inBytes);
+		
+		// The function fwrite() writes nitems objects, each size bytes long, to the
+		// stream pointed to by stream, obtaining them from the location given by
+		// ptr.
+		// fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+		lime::fwrite (array.Bytes (), 1, array.Size (), file);
+		
+		lime::fclose (file);
+		return alloc_null ();
+		
+	}
+	
+	
+	value lime_byte_array_read_file (value inFilename) {
+		
+		ByteArray result = ByteArray (val_os_string(inFilename));
+		
+		return result.mValue;
+		
+	}
+	
+	
+	DEFINE_PRIM (lime_byte_array_get_native_pointer, 1);
+	DEFINE_PRIM (lime_byte_array_init, 4);
+	DEFINE_PRIM (lime_byte_array_overwrite_file, 2);
+	DEFINE_PRIM (lime_byte_array_read_file, 1);
+	
+	
 }
\ No newline at end of file