diff --git a/libraries/text-components/build.gradle b/libraries/text-components/build.gradle
new file mode 100644
index 00000000..7bb43400
--- /dev/null
+++ b/libraries/text-components/build.gradle
@@ -0,0 +1,5 @@
+setUpLibrary(project)
+
+dependencies {
+	implementation 'com.google.code.gson:gson:2.8.0'
+}
diff --git a/libraries/text-components/gradle.properties b/libraries/text-components/gradle.properties
new file mode 100644
index 00000000..1d71ad08
--- /dev/null
+++ b/libraries/text-components/gradle.properties
@@ -0,0 +1,6 @@
+library_id = text-components
+library_name = Text Components
+library_description = Versatile text components.
+library_version = 0.1.0-alpha.1
+
+osl_dependencies = core:>=0.7.0
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/ClickEvent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/ClickEvent.java
new file mode 100644
index 00000000..65e722df
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/ClickEvent.java
@@ -0,0 +1,64 @@
+package net.ornithemc.osl.text.api;
+
+import java.util.Locale;
+import java.util.Objects;
+
+public class ClickEvent {
+
+	private final Action action;
+	private final String value;
+
+	public ClickEvent(Action action, String value) {
+		this.action = action;
+		this.value = value;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof ClickEvent)) {
+			return false;
+		}
+		ClickEvent event = (ClickEvent) o;
+		return this.action == event.action && Objects.equals(this.value, event.value);
+	}
+
+	public Action getAction() {
+		return this.action;
+	}
+
+	public String getValue() {
+		return this.value;
+	}
+
+	public static ClickEvent openUrl(String url) {
+		return new ClickEvent(Action.OPEN_URL, url);
+	}
+
+	public static ClickEvent runCommand(String command) {
+		return new ClickEvent(Action.RUN_COMMAND, command);
+	}
+
+	public static ClickEvent suggestCommand(String command) {
+		return new ClickEvent(Action.SUGGEST_COMMAND, command);
+	}
+
+	public static ClickEvent copyToClipboard(String text) {
+		return new ClickEvent(Action.COPY_TO_CLIPBOARD, text);
+	}
+
+	public enum Action {
+
+		OPEN_URL, RUN_COMMAND, SUGGEST_COMMAND, COPY_TO_CLIPBOARD;
+
+		public String getName() {
+			return this.name().toLowerCase(Locale.ROOT);
+		}
+
+		public static Action byName(String name) {
+			return Action.valueOf(name.toUpperCase());
+		}
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Formatting.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Formatting.java
new file mode 100644
index 00000000..1a577845
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Formatting.java
@@ -0,0 +1,68 @@
+package net.ornithemc.osl.text.api;
+
+public enum Formatting {
+
+	BLACK        ('0', 0x000000),
+	DARK_BLUE    ('1', 0x0000AA),
+	DARK_GREEN   ('2', 0x00AA00),
+	DARK_AQUA    ('3', 0x00AAAA),
+	DARK_RED     ('4', 0xAA0000),
+	DARK_PURPLE  ('5', 0xAA00AA),
+	GOLD         ('6', 0xFFAA00),
+	GRAY         ('7', 0xAAAAAA),
+	DARK_GRAY    ('8', 0x555555),
+	BLUE         ('9', 0x5555FF),
+	GREEN        ('a', 0x55FF55),
+	AQUA         ('b', 0x55FFFF),
+	RED          ('c', 0xFF5555),
+	LIGHT_PURPLE ('d', 0xFF55FF),
+	YELLOW       ('e', 0xFFFF55),
+	WHITE        ('f', 0xFFFFFF),
+	OBFUSCATED   ('k'),
+	BOLD         ('l'),
+	STRIKETHROUGH('m'),
+	UNDERLINED   ('n'),
+	ITALIC       ('o'),
+	RESET        ('r');
+
+	public static final char PREFIX = '§';
+
+	final char code;
+	final Integer color;
+
+	private Formatting(char code) {
+		this(code, null);
+	}
+
+	private Formatting(char code, Integer color) {
+		this.code = code;
+		this.color = color;
+	}
+
+	@Override
+	public String toString() {
+		return "" + PREFIX + this.code;
+	}
+
+	public char getCode() {
+		return this.code;
+	}
+
+	public boolean isColor() {
+		return this.color != null;
+	}
+
+	public Integer getColor() {
+		return this.color;
+	}
+
+	public static Formatting byCode(char code) {
+		for (Formatting f : Formatting.values()) {
+			if (f.code == code) {
+				return f;
+			}
+		}
+
+		throw new IllegalStateException("unknown text formatting code " + code);
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/HoverEvent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/HoverEvent.java
new file mode 100644
index 00000000..332d3a32
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/HoverEvent.java
@@ -0,0 +1,52 @@
+package net.ornithemc.osl.text.api;
+
+import java.util.Locale;
+import java.util.Objects;
+
+public class HoverEvent {
+
+	private final Action action;
+	private final Object value;
+
+	public HoverEvent(Action action, Object value) {
+		this.action = action;
+		this.value = value;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof HoverEvent)) {
+			return false;
+		}
+		HoverEvent event = (HoverEvent) o;
+		return this.action == event.action && Objects.equals(this.value, event.value);
+	}
+
+	public Action getAction() {
+		return this.action;
+	}
+
+	public <T> T getValue() {
+		return (T) this.value;
+	}
+
+	public static HoverEvent showText(TextComponent text) {
+		return new HoverEvent(Action.SHOW_TEXT, text);
+	}
+
+	public enum Action {
+
+		SHOW_TEXT;
+
+		public String getName() {
+			return this.name().toLowerCase(Locale.ROOT);
+		}
+
+		public static Action byName(String name) {
+			return Action.valueOf(name.toUpperCase());
+		}
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Style.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Style.java
new file mode 100644
index 00000000..48af6253
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/Style.java
@@ -0,0 +1,539 @@
+package net.ornithemc.osl.text.api;
+
+import java.lang.reflect.Type;
+import java.util.Objects;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+public final class Style {
+	
+	public static final Style EMPTY = new Style(null, null, null, null, null, null, null, null, null);
+
+	private final TextColor color;
+	private final Boolean bold;
+	private final Boolean italic;
+	private final Boolean underlined;
+	private final Boolean strikethrough;
+	private final Boolean obfuscated;
+	private final String insertion;
+	private final ClickEvent clickEvent;
+	private final HoverEvent hoverEvent;
+
+	private Style(
+		TextColor color,
+		Boolean bold,
+		Boolean italic,
+		Boolean underlined,
+		Boolean strikethrough,
+		Boolean obfuscated,
+		String insertion,
+		ClickEvent clickEvent,
+		HoverEvent hoverEvent
+	) {
+		this.color = color;
+		this.bold = bold;
+		this.italic = italic;
+		this.underlined = underlined;
+		this.strikethrough = strikethrough;
+		this.obfuscated = obfuscated;
+		this.insertion = insertion;
+		this.clickEvent = clickEvent;
+		this.hoverEvent = hoverEvent;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof Style)) {
+			return false;
+		}
+		Style style = (Style) o;
+		return this.color == style.color
+			&& this.bold == style.bold
+			&& this.italic == style.italic
+			&& this.obfuscated == style.obfuscated
+			&& this.strikethrough == style.strikethrough
+			&& this.underlined == style.underlined
+			&& Objects.equals(this.insertion, style.insertion)
+			&& Objects.equals(this.clickEvent, style.clickEvent)
+			&& Objects.equals(this.hoverEvent, style.hoverEvent);
+	}
+
+	public TextColor getColor() {
+		return this.color;
+	}
+
+	public boolean isBold() {
+		return this.bold == Boolean.TRUE;
+	}
+
+	public boolean isItalic() {
+		return this.italic == Boolean.TRUE;
+	}
+
+	public boolean isStrikethrough() {
+		return this.strikethrough == Boolean.TRUE;
+	}
+
+	public boolean isUnderlined() {
+		return this.underlined == Boolean.TRUE;
+	}
+
+	public boolean isObfuscated() {
+		return this.obfuscated == Boolean.TRUE;
+	}
+
+	public String getInsertion() {
+		return this.insertion;
+	}
+
+	public ClickEvent getClickEvent() {
+		return this.clickEvent;
+	}
+
+	public HoverEvent getHoverEvent() {
+		return this.hoverEvent;
+	}
+
+	public boolean isEmpty() {
+		return this == EMPTY;
+	}
+
+	private static <T> Style checkEmptyAfterChange(Style style, T oldValue, T newValue) {
+		return oldValue != null && newValue == null && style.equals(EMPTY) ? EMPTY : style;
+	}
+
+	public Style withColor(int color) {
+		return this.withColor(TextColor.of(color));
+	}
+
+	public Style withColor(Formatting formatting) {
+		return this.withColor(TextColor.fromFormatting(formatting));
+	}
+
+	public Style withColor(TextColor color) {
+		return Objects.equals(this.color, color)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.color,
+				color
+			);
+	}
+
+	public Style withBold(Boolean bold) {
+		return Objects.equals(this.bold, bold)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.bold,
+				bold
+			);
+	}
+
+	public Style withItalic(Boolean italic) {
+		return Objects.equals(this.italic, italic)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.italic,
+				italic
+			);
+	}
+
+	public Style withUnderlined(Boolean underlined) {
+		return Objects.equals(this.underlined, underlined)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.underlined,
+				underlined
+			);
+	}
+
+	public Style withStrikethrough(Boolean strikethrough) {
+		return Objects.equals(this.strikethrough, strikethrough)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.strikethrough,
+				strikethrough
+			);
+	}
+
+	public Style withObfuscated(Boolean obfuscated) {
+		return Objects.equals(this.obfuscated, obfuscated)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					obfuscated,
+					this.insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.obfuscated,
+				obfuscated
+			);
+	}
+
+	public Style withInsertion(String insertion) {
+		return Objects.equals(this.insertion, insertion)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					insertion,
+					this.clickEvent,
+					this.hoverEvent
+				),
+				this.insertion,
+				insertion
+			);
+	}
+
+	public Style withClickEvent(ClickEvent clickEvent) {
+		return Objects.equals(this.clickEvent, clickEvent)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					clickEvent,
+					this.hoverEvent
+				),
+				this.clickEvent,
+				clickEvent
+			);
+	}
+
+	public Style withHoverEvent(HoverEvent hoverEvent) {
+		return Objects.equals(this.hoverEvent, hoverEvent)
+			? this
+			: checkEmptyAfterChange(
+				new Style(
+					this.color,
+					this.bold,
+					this.italic,
+					this.underlined,
+					this.strikethrough,
+					this.obfuscated,
+					this.insertion,
+					this.clickEvent,
+					hoverEvent
+				),
+				this.hoverEvent,
+				hoverEvent
+			);
+	}
+
+	public Style withFormatting(Formatting... formattings) {
+		TextColor color = this.color;
+		Boolean bold = this.bold;
+		Boolean italic = this.italic;
+		Boolean strikethrough = this.strikethrough;
+		Boolean underlined = this.underlined;
+		Boolean obfuscated = this.obfuscated;
+
+		for (Formatting formatting : formattings) {
+			switch (formatting) {
+			case RESET:
+				return EMPTY;
+			case OBFUSCATED:
+				obfuscated = true;
+				break;
+			case BOLD:
+				bold = true;
+				break;
+			case STRIKETHROUGH:
+				strikethrough = true;
+				break;
+			case UNDERLINED:
+				underlined = true;
+				break;
+			case ITALIC:
+				italic = true;
+				break;
+			default:
+				if (formatting.isColor()) {
+					color = TextColor.fromFormatting(formatting);
+				}
+			}
+		}
+
+		return new Style(
+			color,
+			bold,
+			italic,
+			underlined,
+			strikethrough,
+			obfuscated,
+			this.insertion,
+			this.clickEvent,
+			this.hoverEvent
+		);
+	}
+
+	public Style withStyle(Style style) {
+		if (this == EMPTY) {
+			return style;
+		}
+		if (style == EMPTY) {
+			return this;
+		}
+		return new Style(
+			this.color != null ? this.color : style.color,
+			this.bold != null ? this.bold : style.bold,
+			this.italic != null ? this.italic : style.italic,
+			this.underlined != null ? this.underlined : style.underlined,
+			this.strikethrough != null ? this.strikethrough : style.strikethrough,
+			this.obfuscated != null ? this.obfuscated : style.obfuscated,
+			this.insertion != null ? this.insertion : style.insertion,
+			this.clickEvent != null ? this.clickEvent : style.clickEvent,
+			this.hoverEvent != null ? this.hoverEvent : style.hoverEvent
+		);
+	}
+
+	public void apply(StringBuilder sb) {
+		if (this.color != null) {
+			Formatting formatting = this.color.getFormatting();
+
+			if (formatting != null) {
+				sb.append(formatting);
+			}
+		}
+		if (this.bold != null) {
+			sb.append(Formatting.BOLD);
+		}
+		if (this.italic != null) {
+			sb.append(Formatting.ITALIC);
+		}
+		if (this.underlined != null) {
+			sb.append(Formatting.UNDERLINED);
+		}
+		if (this.strikethrough != null) {
+			sb.append(Formatting.STRIKETHROUGH);
+		}
+		if (this.obfuscated != null) {
+			sb.append(Formatting.OBFUSCATED);
+		}
+	}
+
+	public static class Serializer implements JsonDeserializer<Style>, JsonSerializer<Style> {
+
+		private static final String COLOR = "color";
+		private static final String BOLD = "bold";
+		private static final String ITALIC = "italic";
+		private static final String UNDERLINED = "underlined";
+		private static final String STRIKETHROUGH = "strikethrough";
+		private static final String OBFUSCATED = "obfuscated";
+		private static final String INSERTION = "insertion";
+		private static final String CLICK_EVENT = "clickEvent";
+		private static final String HOVER_EVENT = "hoverEveant";
+		private static final String ACTION = "action";
+		private static final String VALUE = "value";
+
+		public Style deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
+			if (!json.isJsonObject()) {
+				return null;
+			}
+
+			JsonObject styleJson = json.getAsJsonObject();
+
+			if (styleJson == null) {
+				return null;
+			}
+
+			TextColor color = null;
+			Boolean bold = null;
+			Boolean italic = null;
+			Boolean underlined = null;
+			Boolean strikethrough = null;
+			Boolean obfuscated = null;
+			String insertion = null;
+			ClickEvent clickEvent = null;
+			HoverEvent hoverEvent = null;
+
+			if (styleJson.has(COLOR)) {
+				color = TextColor.fromFormatting(context.deserialize(styleJson.get(COLOR), Formatting.class));
+			}
+			if (styleJson.has(BOLD)) {
+				bold = styleJson.get(BOLD).getAsBoolean();
+			}
+			if (styleJson.has(ITALIC)) {
+				italic = styleJson.get(ITALIC).getAsBoolean();
+			}
+			if (styleJson.has(UNDERLINED)) {
+				underlined = styleJson.get(UNDERLINED).getAsBoolean();
+			}
+			if (styleJson.has(STRIKETHROUGH)) {
+				strikethrough = styleJson.get(STRIKETHROUGH).getAsBoolean();
+			}
+			if (styleJson.has(OBFUSCATED)) {
+				obfuscated = styleJson.get(OBFUSCATED).getAsBoolean();
+			}
+			if (styleJson.has(INSERTION)) {
+				insertion = styleJson.get(INSERTION).getAsString();
+			}
+			if (styleJson.has(CLICK_EVENT)) {
+				JsonObject ceJson = styleJson.getAsJsonObject(CLICK_EVENT);
+				if (ceJson.has(ACTION) && ceJson.has(VALUE)) {
+					String actionName = ceJson.get(ACTION).getAsString();
+					String value = ceJson.get(VALUE).getAsString();
+
+					ClickEvent.Action action = ClickEvent.Action.byName(actionName);
+
+					if (action != null) {
+						clickEvent = new ClickEvent(action, value);
+					}
+				}
+			}
+			if (styleJson.has(HOVER_EVENT)) {
+				JsonObject heJson = styleJson.getAsJsonObject(HOVER_EVENT);
+				if (heJson.has(ACTION) && heJson.has(VALUE)) {
+					String actionName = heJson.get(ACTION).getAsString();
+					String value = heJson.get(VALUE).getAsString();
+
+					HoverEvent.Action action = HoverEvent.Action.byName(actionName);
+
+					if (action != null) {
+						hoverEvent = new HoverEvent(action, value);
+					}
+				}
+			}
+
+			return new Style(
+				color,
+				bold,
+				italic,
+				underlined,
+				strikethrough,
+				obfuscated,
+				insertion,
+				clickEvent,
+				hoverEvent
+			);
+		}
+
+		public JsonElement serialize(Style style, Type type, JsonSerializationContext context) {
+			if (style.isEmpty()) {
+				return null;
+			}
+
+			JsonObject json = new JsonObject();
+
+			if (style.bold != null) {
+				json.addProperty(BOLD, style.bold);
+			}
+			if (style.italic != null) {
+				json.addProperty(ITALIC, style.italic);
+			}
+			if (style.underlined != null) {
+				json.addProperty(UNDERLINED, style.underlined);
+			}
+			if (style.strikethrough != null) {
+				json.addProperty(STRIKETHROUGH, style.strikethrough);
+			}
+			if (style.obfuscated != null) {
+				json.addProperty(OBFUSCATED, style.obfuscated);
+			}
+			if (style.color != null) {
+				json.add(COLOR, context.serialize(style.color));
+			}
+			if (style.insertion != null) {
+				json.add(INSERTION, context.serialize(style.insertion));
+			}
+			if (style.clickEvent != null) {
+				JsonObject ceJson = new JsonObject();
+
+				ceJson.addProperty(ACTION, style.clickEvent.getAction().name().toLowerCase());
+				ceJson.addProperty(VALUE, style.clickEvent.getValue());
+
+				json.add(CLICK_EVENT, ceJson);
+			}
+
+			if (style.hoverEvent != null) {
+				JsonObject heJson = new JsonObject();
+
+				heJson.addProperty(ACTION, style.hoverEvent.getAction().name().toLowerCase());
+				heJson.add(VALUE, context.serialize(style.hoverEvent.getValue()));
+
+				json.add(HOVER_EVENT, heJson);
+			}
+
+			return json;
+		}
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextColor.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextColor.java
new file mode 100644
index 00000000..e5a5f710
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextColor.java
@@ -0,0 +1,71 @@
+package net.ornithemc.osl.text.api;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+public class TextColor {
+
+	private static final Map<Formatting, TextColor> BY_FORMATTING = new EnumMap<>(Formatting.class);
+
+	public static final TextColor BLACK = new TextColor(Formatting.BLACK);
+	public static final TextColor DARK_BLUE = new TextColor(Formatting.DARK_BLUE);
+	public static final TextColor DARK_GREEN = new TextColor(Formatting.DARK_GREEN);
+	public static final TextColor DARK_AQUA = new TextColor(Formatting.DARK_AQUA);
+	public static final TextColor DARK_RED = new TextColor(Formatting.DARK_RED);
+	public static final TextColor DARK_PURPLE = new TextColor(Formatting.DARK_PURPLE);
+	public static final TextColor GOLD = new TextColor(Formatting.GOLD);
+	public static final TextColor GRAY = new TextColor(Formatting.GRAY);
+	public static final TextColor DARK_GRAY = new TextColor(Formatting.DARK_GRAY);
+	public static final TextColor BLUE = new TextColor(Formatting.BLUE);
+	public static final TextColor GREEN = new TextColor(Formatting.GREEN);
+	public static final TextColor AQUA = new TextColor(Formatting.AQUA);
+	public static final TextColor RED = new TextColor(Formatting.RED);
+	public static final TextColor LIGHT_PURPLE = new TextColor(Formatting.LIGHT_PURPLE);
+	public static final TextColor YELLOW = new TextColor(Formatting.YELLOW);
+	public static final TextColor WHITE = new TextColor(Formatting.WHITE);
+
+	private final Formatting formatting;
+	private final int color;
+
+	private TextColor(Formatting formatting) {
+		BY_FORMATTING.put(formatting, this);
+
+		this.formatting = formatting;
+		this.color = formatting.color;
+	}
+
+	private TextColor(int color) {
+		this.formatting = null;
+		this.color = color;
+	}
+
+	public int getColor() {
+		return this.color;
+	}
+
+	public boolean isFormatting() {
+		return this.formatting != null;
+	}
+
+	public Formatting getFormatting() {
+		return this.formatting;
+	}
+
+	public static TextColor of(int color) {
+		return new TextColor(color);
+	}
+
+	public static TextColor fromFormatting(Formatting formatting) {
+		if (formatting.isColor()) {
+			TextColor color = BY_FORMATTING.get(formatting);
+
+			if (color != null) {
+				return color;
+			}
+
+			throw new IllegalStateException("could not resolve text color " + formatting.name());
+		} else {
+			return null;
+		}
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponent.java
new file mode 100644
index 00000000..46ffba51
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponent.java
@@ -0,0 +1,226 @@
+package net.ornithemc.osl.text.api;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.UnaryOperator;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+
+import net.ornithemc.osl.text.impl.LiteralTextComponent;
+import net.ornithemc.osl.text.impl.TranslatableTextComponent;
+
+public interface TextComponent {
+
+	Style getStyle();
+
+	List<TextComponent> getSiblings();
+
+	TextComponent format(Formatting... formattings);
+
+	TextComponent format(Style style);
+
+	TextComponent format(UnaryOperator<Style> styler);
+
+	TextComponent append(String text);
+
+	TextComponent append(TextComponent text);
+
+	String buildString();
+
+	String buildFormattedString();
+
+	class Serializer implements JsonDeserializer<TextComponent>, JsonSerializer<TextComponent> {
+
+		@Override
+		public TextComponent deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
+			if (json.isJsonPrimitive()) {
+				return TextComponents.literal(json.getAsString());
+			} else if (json.isJsonArray()) {
+				JsonArray siblingsJson = json.getAsJsonArray();
+				TextComponent text = null;
+
+				for (JsonElement jsonElement2 : siblingsJson) {
+					TextComponent sibling = this.deserialize(jsonElement2, jsonElement2.getClass(), context);
+
+					if (text == null) {
+						text = sibling;
+					} else {
+						text.append(sibling);
+					}
+				}
+
+				return text;
+			} else if (json.isJsonObject()) {
+				JsonObject textJson = json.getAsJsonObject();
+
+				TextComponent text;
+
+				if (textJson.has("text")) {
+					text = TextComponents.literal(textJson.get("text").getAsString());
+				} else if (textJson.has("translate")) {
+					String key = textJson.get("translate").getAsString();
+
+					if (textJson.has("with")) {
+						JsonArray argsJson = textJson.get("with").getAsJsonArray();
+						Object[] args = new Object[argsJson.size()];
+
+						for (int i = 0; i < args.length; i++) {
+							args[i] = context.deserialize(argsJson.get(i), TextComponent.class);
+
+							if (args[i] instanceof LiteralTextComponent) {
+								LiteralTextComponent arg = (LiteralTextComponent) args[i];
+
+								if (arg.getStyle().isEmpty() && arg.getSiblings().isEmpty()) {
+									args[i] = arg.getValue();
+								}
+							}
+						}
+
+						text = TextComponents.translatable(key, args);
+					} else {
+						text = TextComponents.translatable(key);
+					}
+				} else {
+					throw new JsonParseException("Don't know how to turn " + json + " into a TextComponent");
+				}
+
+				if (textJson.has("extra")) {
+					JsonArray siblingsJson = textJson.get("extra").getAsJsonArray();
+
+					if (siblingsJson.size() <= 0) {
+						throw new JsonParseException("Unexpected empty array of TextComponents");
+					}
+
+					for (int i = 0; i < siblingsJson.size(); i++) {
+						text.append(this.deserialize(siblingsJson.get(i), type, context));
+					}
+				}
+
+				return text;
+			} else {
+				throw new JsonParseException("Don't know how to turn " + json + " into a TextComponent");
+			}
+		}
+
+		private void serializeStyle(Style style, JsonObject textJson, JsonSerializationContext context) {
+			JsonElement styleJson = context.serialize(style);
+
+			if (styleJson.isJsonObject()) {
+				for (Map.Entry<String, JsonElement> entry : styleJson.getAsJsonObject().entrySet()) {
+					textJson.add(entry.getKey(), entry.getValue());
+				}
+			}
+		}
+
+		@Override
+		public JsonElement serialize(TextComponent text, Type type, JsonSerializationContext context) {
+			JsonObject textJson = new JsonObject();
+
+			if (!text.getStyle().isEmpty()) {
+				this.serializeStyle(text.getStyle(), textJson, context);
+			}
+
+			if (!text.getSiblings().isEmpty()) {
+				JsonArray jsonArray = new JsonArray();
+
+				for (TextComponent sibling : text.getSiblings()) {
+					jsonArray.add(this.serialize(sibling, sibling.getClass(), context));
+				}
+
+				textJson.add("extra", jsonArray);
+			}
+
+			if (text instanceof LiteralTextComponent) {
+				textJson.addProperty("text", ((LiteralTextComponent) text).getValue());
+			} else if (text instanceof TranslatableTextComponent) {
+				TranslatableTextComponent translatableText = (TranslatableTextComponent) text;
+
+				textJson.addProperty("translate", translatableText.getKey());
+
+				if (translatableText.getArgs() != null && translatableText.getArgs().length > 0) {
+					JsonArray argsJson = new JsonArray();
+
+					for (Object arg : translatableText.getArgs()) {
+						if (arg instanceof TextComponent) {
+							argsJson.add(this.serialize((TextComponent) arg, arg.getClass(), context));
+						} else {
+							argsJson.add(new JsonPrimitive(String.valueOf(arg)));
+						}
+					}
+
+					textJson.add("with", argsJson);
+				}
+			} else {
+				throw new IllegalArgumentException("Don't know how to serialize " + text + " as a TextComponent");
+			}
+
+			return textJson;
+		}
+
+		public static class LowercaseEnumTypeAdapterFactory implements TypeAdapterFactory {
+
+			@Override
+			public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> token) {
+				@SuppressWarnings("unchecked")
+				Class<T> type = (Class<T>) token.getRawType();
+
+				if (!type.isEnum()) {
+					return null;
+				}
+
+				Map<String, T> constants = new HashMap<>();
+
+				for (T constant : type.getEnumConstants()) {
+					constants.put(this.toString(constant), constant);
+				}
+
+				return new TypeAdapter<T>() {
+
+					@Override
+					public void write(JsonWriter writer, T constant) throws IOException {
+						if (constant == null) {
+							writer.nullValue();
+						} else {
+							writer.value(LowercaseEnumTypeAdapterFactory.this.toString(constant));
+						}
+					}
+
+					@Override
+					public T read(JsonReader reader) throws IOException {
+						if (reader.peek() == JsonToken.NULL) {
+							reader.nextNull();
+							return null;
+						} else {
+							return constants.get(reader.nextString());
+						}
+					}
+				};
+			}
+
+			private String toString(Object constant) {
+				return constant instanceof Enum
+					? ((Enum<?>) constant).name().toLowerCase(Locale.ROOT)
+					: constant.toString().toLowerCase(Locale.ROOT);
+			}
+		}
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponents.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponents.java
new file mode 100644
index 00000000..783532fb
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/api/TextComponents.java
@@ -0,0 +1,67 @@
+package net.ornithemc.osl.text.api;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+
+import net.ornithemc.osl.text.api.TextComponent.Serializer;
+import net.ornithemc.osl.text.api.TextComponent.Serializer.LowercaseEnumTypeAdapterFactory;
+import net.ornithemc.osl.text.impl.LiteralTextComponent;
+import net.ornithemc.osl.text.impl.TextResolvers;
+import net.ornithemc.osl.text.impl.TranslatableTextComponent;
+
+public final class TextComponents {
+
+	private static final Gson GSON = new GsonBuilder()
+		.disableHtmlEscaping()
+		.registerTypeHierarchyAdapter(TextComponent.class, new Serializer())
+		.registerTypeHierarchyAdapter(Style.class, new Style.Serializer())
+		.registerTypeAdapterFactory(new LowercaseEnumTypeAdapterFactory())
+		.create();
+
+	public static TextComponent literal(String t) {
+		return new LiteralTextComponent(t);
+	}
+
+	public static TextComponent literal(String t, Object... args) {
+		return new LiteralTextComponent(String.format(t, args));
+	}
+
+	public static TextComponent translatable(String t) {
+		return new TranslatableTextComponent(t);
+	}
+
+	public static TextComponent translatable(String t, Object... args) {
+		return new TranslatableTextComponent(t, args);
+	}
+
+	public static TextComponent resolve(Object o) {
+		return TextResolvers.resolve(o);
+	}
+
+	public static TextComponent composite(Object... ts) {
+		TextComponent c = literal("");
+
+		for (Object t : ts) {
+			c.append(resolve(t));
+		}
+
+		return c;
+	}
+
+	public static TextComponent fromJson(String json) {
+		return GSON.fromJson(json, TextComponent.class);
+	}
+
+	public static TextComponent fromJsonTree(JsonElement json) {
+		return GSON.fromJson(json, TextComponent.class);
+	}
+
+	public static String toJson(TextComponent t) {
+		return GSON.toJson(t);
+	}
+
+	public static JsonElement toJsonTree(TextComponent t) {
+		return GSON.toJsonTree(t);
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/BaseTextComponent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/BaseTextComponent.java
new file mode 100644
index 00000000..f69a28b8
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/BaseTextComponent.java
@@ -0,0 +1,101 @@
+package net.ornithemc.osl.text.impl;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.UnaryOperator;
+
+import net.ornithemc.osl.text.api.Formatting;
+import net.ornithemc.osl.text.api.Style;
+import net.ornithemc.osl.text.api.TextComponent;
+import net.ornithemc.osl.text.api.TextComponents;
+
+abstract class BaseTextComponent implements TextComponent {
+
+	private final List<TextComponent> siblings;
+
+	Style style;
+
+	BaseTextComponent() {
+		this.siblings = new ArrayList<>();
+
+		this.style = Style.EMPTY;
+	}
+
+	@Override
+	public Style getStyle() {
+		return this.style;
+	}
+
+	@Override
+	public TextComponent format(Formatting... formattings) {
+		this.style = this.style.withFormatting(formattings);
+		return this;
+	}
+
+	@Override
+	public TextComponent format(Style style) {
+		this.style = style;
+		return this;
+	}
+
+	@Override
+	public TextComponent format(UnaryOperator<Style> styler) {
+		this.style = styler.apply(this.style);
+		return this;
+	}
+
+	@Override
+	public TextComponent append(String text) {
+		this.siblings.add(TextComponents.literal(text));
+		return this;
+	}
+
+	@Override
+	public TextComponent append(TextComponent text) {
+		this.siblings.add(text);
+		return this;
+	}
+
+	@Override
+	public String buildString() {
+		return this.buildString(false);
+	}
+
+	@Override
+	public String buildFormattedString() {
+		return this.buildString(true);
+	}
+
+	private String buildString(boolean formatted) {
+		StringBuilder sb = new StringBuilder();
+
+		this.buildString(sb, formatted);
+		this.buildString(sb, formatted, this.siblings);
+
+		if (formatted) {
+			sb.append(Formatting.RESET);
+		}
+
+		return sb.toString();
+	}
+
+	abstract void buildString(StringBuilder sb, boolean formatted);
+
+	final void buildString(StringBuilder sb, boolean formatted, List<TextComponent> texts) {
+		for (TextComponent text : texts) {
+			if (formatted) {
+				this.style.apply(sb);
+			}
+
+			sb.append(formatted
+				? text.buildFormattedString()
+				: text.buildString());
+		}
+	}
+
+	@Override
+	public List<TextComponent> getSiblings() {
+		return Collections.unmodifiableList(this.siblings);
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/FormattedStringResolver.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/FormattedStringResolver.java
new file mode 100644
index 00000000..084cdf6b
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/FormattedStringResolver.java
@@ -0,0 +1,70 @@
+package net.ornithemc.osl.text.impl;
+
+import net.ornithemc.osl.text.api.Formatting;
+import net.ornithemc.osl.text.api.Style;
+import net.ornithemc.osl.text.api.TextComponent;
+import net.ornithemc.osl.text.api.TextComponents;
+
+public class FormattedStringResolver implements TextResolver<String> {
+
+	@Override
+	public TextComponent resolve(String fs) {
+		TextComponent t = TextComponents.literal("");
+		Style s = Style.EMPTY;
+
+		int from = 0;
+		int to = 0;
+
+		boolean lastWasFormattingPrefix = false;
+		boolean lastWasFormatting = false;
+
+		for (; to < fs.length(); to++) {
+			char chr = fs.charAt(to);
+
+			boolean thisIsFormattingPrefix = (chr == Formatting.PREFIX);
+			boolean thisIsStringEnd = (to == fs.length() - 1);
+
+			if (lastWasFormattingPrefix) {
+				Formatting f = Formatting.byCode(chr);
+
+				if (f == Formatting.RESET) {
+					s = Style.EMPTY;
+				} else {
+					s = s.withFormatting(f);
+				}
+
+				// make sure current char is not captured
+				if (thisIsStringEnd) {
+					from = to;
+				}
+
+				lastWasFormattingPrefix = false;
+				lastWasFormatting = true;
+			} else if (thisIsFormattingPrefix) {
+				lastWasFormattingPrefix = true;
+				lastWasFormatting = false;
+			} else {
+				if (lastWasFormatting) {
+					from = to;
+				}
+				// make sure current char is captured
+				if (thisIsStringEnd) {
+					to++;
+				}
+
+				lastWasFormattingPrefix = false;
+				lastWasFormatting = false;
+			}
+
+			if (thisIsFormattingPrefix || thisIsStringEnd) {
+				if (from != to) {
+					t.append(TextComponents.literal(fs.substring(from, to)).format(s));
+				}
+
+				from = to;
+			}
+		}
+
+		return t;
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/LiteralTextComponent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/LiteralTextComponent.java
new file mode 100644
index 00000000..6a854f54
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/LiteralTextComponent.java
@@ -0,0 +1,23 @@
+package net.ornithemc.osl.text.impl;
+
+public class LiteralTextComponent extends BaseTextComponent {
+
+	private final String value;
+
+	public LiteralTextComponent(String value) {
+		this.value = value;
+	}
+
+	public String getValue() {
+		return this.value;
+	}
+
+	@Override
+	void buildString(StringBuilder sb, boolean formatted) {
+		if (formatted) {
+			this.style.apply(sb);
+		}
+
+		sb.append(this.value);
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/Locale.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/Locale.java
new file mode 100644
index 00000000..6e5fb5fc
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/Locale.java
@@ -0,0 +1,33 @@
+package net.ornithemc.osl.text.impl;
+
+import java.lang.reflect.Method;
+
+public interface Locale {
+
+	static Locale find() {
+		try {
+			Class<?> type = Class.forName("net.ornithemc.osl.localization.impl.Locale");
+			Method instance = type.getMethod("instance");
+
+			return (Locale) instance.invoke(null);
+		} catch (Throwable t) {
+			return new Locale() {
+
+				@Override
+				public long getLastUpdateTime() {
+					return 0;
+				}
+
+				@Override
+				public String get(String key) {
+					return key;
+				}
+			};
+		}
+	}
+
+	long getLastUpdateTime();
+
+	String get(String key);
+
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolver.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolver.java
new file mode 100644
index 00000000..bc3d8356
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolver.java
@@ -0,0 +1,9 @@
+package net.ornithemc.osl.text.impl;
+
+import net.ornithemc.osl.text.api.TextComponent;
+
+public interface TextResolver<T> {
+
+	TextComponent resolve(T o);
+
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolvers.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolvers.java
new file mode 100644
index 00000000..34b5a526
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TextResolvers.java
@@ -0,0 +1,39 @@
+package net.ornithemc.osl.text.impl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.ornithemc.osl.text.api.TextComponent;
+
+public class TextResolvers {
+
+	private static Map<Class<?>, TextResolver<?>> resolvers = new HashMap<>();
+
+	static {
+		register(String.class, new FormattedStringResolver());
+	}
+
+	public static <T> void register(Class<T> type, TextResolver<T> resolver) {
+		if (resolvers.containsKey(type)) {
+			throw new IllegalStateException("cannot register multiple text component resolvers for type " + type.getName());
+		} else {
+			resolvers.put(type, resolver);
+		}
+	}
+
+	public static TextComponent resolve(Object o) {
+		Class<?> type = o.getClass();
+		TextResolver<?> resolver = resolvers.get(type);
+
+		if (resolver == null) {
+			return resolve(o.toString());
+		}
+
+		return resolve(resolver, o);
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <T> TextComponent resolve(TextResolver<T> resolver, Object o) {
+		return resolver.resolve((T) o);
+	}
+}
diff --git a/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TranslatableTextComponent.java b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TranslatableTextComponent.java
new file mode 100644
index 00000000..6ad82024
--- /dev/null
+++ b/libraries/text-components/src/main/java/net/ornithemc/osl/text/impl/TranslatableTextComponent.java
@@ -0,0 +1,103 @@
+package net.ornithemc.osl.text.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import net.ornithemc.osl.text.api.TextComponent;
+import net.ornithemc.osl.text.api.TextComponents;
+
+public class TranslatableTextComponent extends BaseTextComponent {
+
+	private static final Pattern ARG_FORMAT = Pattern.compile("%(?:(\\d+)\\$)?([A-Za-z%]|$)");
+	private static final Locale LOCALE = Locale.find();
+
+	private final String key;
+	private final Object[] args;
+
+	private long resolvedTime;
+	private List<TextComponent> resolved;
+
+	public TranslatableTextComponent(String key, Object... args) {
+		this.key = key;
+		this.args = args;
+	}
+
+	public String getKey() {
+		return this.key;
+	}
+
+	public Object[] getArgs() {
+		return this.args;
+	}
+
+	@Override
+	void buildString(StringBuilder sb, boolean formatted) {
+		long localeUpdateTime = LOCALE.getLastUpdateTime();
+
+		if (this.resolved == null || this.resolvedTime != localeUpdateTime) {
+			this.resolve(localeUpdateTime);
+		}
+
+		this.buildString(sb, formatted, this.resolved);
+	}
+
+	private void resolve(long time) {
+		this.resolvedTime = time;
+		this.resolved = new ArrayList<>();
+
+		String translation = LOCALE.get(this.key);
+		Matcher matcher = ARG_FORMAT.matcher(translation);
+
+		int nextArgIndex = 0;
+		int nextCharIndex = 0;
+
+		while (matcher.find(nextCharIndex)) {
+			int matchStart = matcher.start();
+			int matchEnd = matcher.end();
+
+			if (matchStart > nextCharIndex) {
+				this.resolved.add(TextComponents.literal(translation.substring(nextCharIndex, matchStart)));
+			}
+
+			String formatting = matcher.group(2);
+			String partWithFormatting = translation.substring(matchStart, matchEnd);
+
+			if ("%".equals(formatting) && "%%".equals(partWithFormatting)) {
+				this.resolved.add(TextComponents.literal("%"));
+			} else {
+				if (!"s".equals(formatting)) {
+					throw new IllegalStateException("Unsupported format: '" + partWithFormatting + "'");
+				}
+
+				String matchedArgIndex = matcher.group(1);
+				int argIndex = matchedArgIndex != null ? Integer.parseInt(matchedArgIndex) - 1 : nextArgIndex++;
+
+				if (argIndex < this.args.length) {
+					this.resolved.add(this.resolveArg(argIndex));
+				}
+			}
+
+			nextCharIndex = matchEnd;
+		}
+
+		if (nextCharIndex < translation.length()) {
+			this.resolved.add(TextComponents.literal(translation.substring(nextCharIndex)));
+		}
+	}
+
+	private TextComponent resolveArg(int index) {
+		if (index >= this.args.length) {
+			throw new IndexOutOfBoundsException("Index out of range: " + index);
+		}
+
+		Object arg = this.args[index];
+
+		if (arg == null) {
+			return TextComponents.literal("null");
+		}
+
+		return TextComponents.resolve(arg);
+	}
+}
diff --git a/libraries/text-components/text-components-mca0.1.0-mc1.14.4/build.gradle b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/build.gradle
new file mode 100644
index 00000000..0a350fdb
--- /dev/null
+++ b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/build.gradle
@@ -0,0 +1 @@
+setUpModule(project)
diff --git a/libraries/text-components/text-components-mca0.1.0-mc1.14.4/gradle.properties b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/gradle.properties
new file mode 100644
index 00000000..2b13bda2
--- /dev/null
+++ b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/gradle.properties
@@ -0,0 +1,5 @@
+min_mc_version = a0.1.0
+max_mc_version = 1.14.4
+minecraft_dependency = >=1.0.0-alpha.1.0 <=1.14.4
+
+minecraft_version = 1.14.4
diff --git a/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/fabric.mod.json b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/fabric.mod.json
new file mode 100644
index 00000000..edd94c38
--- /dev/null
+++ b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/fabric.mod.json
@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "id": "osl-text-components",
+  "version": "0.1.0-alpha.1+mca0.1.0-mc1.14.4",
+  "environment": "*",
+  "mixins": [
+    "osl.text-components.mixins.json"
+  ],
+  "depends": {
+    "fabricloader": "\u003e\u003d0.18.0",
+    "minecraft": "\u003e\u003d1.0.0-alpha.1.0 \u003c\u003d1.14.4",
+    "osl-core": "\u003e\u003d0.7.0"
+  },
+  "name": "OSL Text Components",
+  "description": "Versatile text components.",
+  "authors": [
+    "OrnitheMC"
+  ],
+  "contact": {
+    "homepage": "https://ornithemc.net/",
+    "issues": "https://github.com/OrnitheMC/ornithe-standard-libraries/issues",
+    "sources": "https://github.com/OrnitheMC/ornithe-standard-libraries"
+  },
+  "license": "Apache-2.0"
+}
\ No newline at end of file
diff --git a/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/osl.text-components.mixins.json b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/osl.text-components.mixins.json
new file mode 100644
index 00000000..7f5c435c
--- /dev/null
+++ b/libraries/text-components/text-components-mca0.1.0-mc1.14.4/src/main/resources/osl.text-components.mixins.json
@@ -0,0 +1,15 @@
+{
+	"required": true,
+	"minVersion": "0.8",
+	"package": "net.ornithemc.osl.text.impl.mixin",
+	"compatibilityLevel": "JAVA_8",
+	"mixins": [
+	],
+	"client": [
+	],
+	"server": [
+	],
+	"injectors": {
+		"defaultRequire": 1
+	}
+}
diff --git a/settings.gradle b/settings.gradle
index 513b01ad..a55db87f 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -104,3 +104,6 @@ include ':libraries:resource-loader:resource-loader-mc16w32a-mc1.12.2'
 include ':libraries:resource-loader:resource-loader-mc17w43a-mc19w07a'
 include ':libraries:resource-loader:resource-loader-mc19w08a-mc1.14.4'
 
+include ':libraries:text-components'
+include ':libraries:text-components:text-components-mca0.1.0-mc1.14.4'
+