diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 37dbb47..abbe8d4 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -33,6 +33,8 @@ jobs:
         with:
           fetch-depth: 0 # Not needed if lastUpdated is not enabled
       - uses: pnpm/action-setup@v2
+        with:
+          version: 8
       - name: Setup Node
         uses: actions/setup-node@v3
         with:
diff --git a/.vitepress/config.mts b/.vitepress/config.mts
index a9d9733..11997a3 100644
--- a/.vitepress/config.mts
+++ b/.vitepress/config.mts
@@ -10,7 +10,8 @@ const allCategoriesSection = [
       { text: "Sounds", link: "/sounds/" },
       { text: "Data Generation", link: "/data-generation/" },
       { text: "Events", link: "/events/" },
-      { text: "Rendering", link: "/rendering/" }
+      { text: "Rendering", link: "/rendering/" },
+      { text: "Miscellaneous Topics", link: "/misc-topics/" }
     ]
   }
 ]
@@ -19,6 +20,36 @@ const allCategoriesSection = [
 export default defineConfig({
   title: "Fabric Modding Wiki",
   description: "An open source guide-book for creating mods using Fabric.",
+
+  head: [
+    ['link', { rel: 'icon', href: '/icon.png' }],
+    ['meta', { name: 'theme-color', content: '#f0430e' }],
+    ['meta', { name: 'twitter:card', content: 'summary' }],
+    ['meta', { name: 'og:image', content: '/icon.png' }]
+  ],
+
+  transformPageData(pageData) {
+    pageData.frontmatter.head ??= []
+    pageData.frontmatter.head.push([
+      'meta',
+      {
+        name: 'og:title',
+        content:
+          pageData.frontmatter.layout === 'home'
+            ? `Fabric Modding Wiki`
+            : `${pageData.title} | Fabric Modding Wiki`
+      }
+    ])
+
+    pageData.frontmatter.head.push([
+      'meta',
+      {
+        name: 'og:description',
+        content: pageData.frontmatter.description || "An open source guide-book for creating mods using Fabric."
+      }
+    ])
+  },
+
   sitemap: {
     hostname: 'https://fabric.moddedmc.wiki/'
   },
@@ -129,6 +160,17 @@ export default defineConfig({
           ]
         }
       ],
+      '/misc-topics/': [
+        ...allCategoriesSection,
+        {
+          text: 'Miscellaneous Topics',
+          items: [
+            { text: 'About This Section', link: '/misc-topics/' },
+            { text: 'Codecs', link: '/misc-topics/codecs' },
+            { text: 'Text and Translations', link: '/misc-topics/text-and-translations' },
+          ]
+        }
+      ]
     },
 
     footer: {
diff --git a/.vitepress/theme/style.css b/.vitepress/theme/style.css
index 456c1f0..cfd4101 100644
--- a/.vitepress/theme/style.css
+++ b/.vitepress/theme/style.css
@@ -137,6 +137,12 @@
   --docsearch-primary-color: var(--vp-c-brand-1) !important;
 }
 
+.vp-doc table {
+  width: 100%;
+  max-width: -moz-fit-content;
+  max-width: fit-content;
+}
+
 p > img {
   margin-left: auto;
   margin-right: auto;
diff --git a/components/ColorSwatch.vue b/components/ColorSwatch.vue
new file mode 100644
index 0000000..13bc270
--- /dev/null
+++ b/components/ColorSwatch.vue
@@ -0,0 +1,20 @@
+<template>
+  <div class="color-swatch" :style="`background-color: ${color}`" />
+</template>
+
+<script setup>
+const { color } = defineProps({
+  color: String,
+});
+</script>
+
+<style scoped>
+.color-swatch {
+  width: 100%;
+  padding: 50%;
+  margin: auto;
+  border-radius: 0.25rem;
+  border-color: grey;
+  border-width: 1px;
+}
+</style>
diff --git a/icon.png b/icon.png
new file mode 100644
index 0000000..6b8062b
Binary files /dev/null and b/icon.png differ
diff --git a/index.md b/index.md
index 2407f66..89b4f73 100644
--- a/index.md
+++ b/index.md
@@ -2,6 +2,9 @@
 # https://vitepress.dev/reference/default-theme-home-page
 layout: home
 
+title: "Fabric Modding Wiki"
+description: "An open source guide-book for creating mods using Fabric."
+
 hero:
   name: "Fabric Modding Wiki"
   tagline: "An open source guide-book for creating mods using Fabric."
@@ -32,6 +35,9 @@ features:
   - title: Sounds
     details: Learn how to utilize Minecraft's sound systems to add and play your own sounds.
     link: /sounds/
+  - title: Miscellaneous Topics
+    details: "Learn about other topics such as codecs, text and more."
+    link: /misc-topics/
 ---
 
 <style scoped>
diff --git a/misc-topics/codecs.md b/misc-topics/codecs.md
new file mode 100644
index 0000000..6a6f6df
--- /dev/null
+++ b/misc-topics/codecs.md
@@ -0,0 +1,439 @@
+---
+title: Codecs 
+description: An advanced guide to using Mojang's Codec system for serializing and deserializing java objects.
+prev: false
+next: false
+---
+
+# Codecs
+
+Codec is a system for easily and functionally serializing java objects, and is included in Mojang's DataFixerUpper (DFU)
+library. In a modding context they are usually used as an alternative to GSON and Jankson when reading and writing
+custom json files, but they tend to be useful in many other situations as well.
+
+They are used in conjunction with another API from DFU, `DynamicOps`. A codec defines the structure of an object, while
+dynamic ops are used to define a format to be serialized to and from, such as json or NBT. This means any codec can be
+used with any dynamic ops, and vice versa, allowing for great flexibility.
+
+## Using Codecs
+
+### Serializing and Deserializing
+
+The basic usage of a codec is to serialize and deserialize objects to and from a specific format.
+
+Since a few vanilla classes already have codecs defined, we can use those as an example. Mojang has also provided us
+with two dynamic ops classes by default, `JsonOps` and `NbtOps`, which tend to cover most use cases.
+
+Now, let's say we want to serialize a `BlockPos` to json and back. We can do this using the codec statically stored
+at `BlockPos.CODEC` with the `Codec#encodeStart` and `Codec#parse` methods, respectively.
+
+```java
+BlockPos pos = new BlockPos(1, 2, 3);
+
+// Serialize the BlockPos to a JsonElement
+DataResult<JsonElement> result = BlockPos.CODEC.encodeStart(JsonOps.INSTANCE, pos);
+```
+
+When using a codec, values are returned in the form of a `DataResult`. This is a wrapper that can represent either a
+success or a failure. We can use this in several ways: If we just want our serialized value, `DataResult#result` will
+simply return an `Optional` containing our value, while `DataResult#resultOrPartial` also lets us supply a function to
+handle any errors that may have occurred. The latter is particularly useful for custom datapack resources, where we'd
+want to log errors without causing issues elsewhere.
+
+So let's grab our serialized value and turn it back into a `BlockPos`:
+
+```java
+// When actually writing a mod, you'll want to properly handle empty Optionals of course
+JsonElement json = result.resultOrPartial(LOGGER::error).orElseThrow();
+
+// Here we have our json value, which should correspond to `[1, 2, 3]`, 
+// as that's the format used by the BlockPos codec.
+LOGGER.info("Serialized BlockPos: {}", json);
+
+// Now we'll deserialize the JsonElement back into a BlockPos
+DataResult<BlockPos> result = BlockPos.CODEC.parse(JsonOps.INSTANCE, json);
+
+// Again, we'll just grab our value from the result
+BlockPos pos = result.resultOrPartial(LOGGER::error).orElseThrow();
+
+// And we can see that we've successfully serialized and deserialized our BlockPos!
+LOGGER.info("Deserialized BlockPos: {}", pos);
+```
+
+### Built-in Codecs
+
+As mentioned earlier, Mojang has already defined codecs for several vanilla and standard Java classes, including but not
+limited to `BlockPos`, `BlockState`, `ItemStack`, `Identifier`, `Text`, and regex `Pattern`s. Codecs for Mojang's own
+classes are usually found as static fields named `CODEC` on the class itself, while most others are kept in the `Codecs`
+class. It should also be noted that all vanilla registries contain a `getCodec()` method, for example, you
+can use `Registries.BLOCK.getCodec()` to get a `Codec<Block>` which serializes to the block id and back.
+
+The codec api itself also contains some codecs for primitive types, such as `Codec.INT` and `Codec.STRING`. These are
+available as statics on the `Codec` class, and are usually used as the base for more complex codecs, as explained below.
+
+## Building Codecs
+
+Now that we've seen how to use codecs, let's take a look at how we can build our own. Suppose we have the following
+class, and we want to deserialize instances of it from json files:
+
+```java
+public class CoolBeansClass {
+    
+    private final int beansAmount;
+    private final Item beanType;
+    private final List<BlockPos> beanPositions;
+
+    public CoolBeansClass(int beansAmount, Item beanType, List<BlockPos> beanPositions) {...}
+
+    public int getBeansAmount() { return this.beansAmount; }
+    public Item getBeanType() { return this.beanType; }
+    public List<BlockPos> getBeanPositions() { return this.beanPositions; }
+}
+```
+
+The corresponding json file might look something like this:
+
+```json
+{
+  "beans_amount": 5,
+  "bean_type": "beanmod:mythical_beans",
+  "bean_positions": [
+    [1, 2, 3],
+    [4, 5, 6]
+  ]
+}
+```
+
+We can make a codec for this class by putting together multiple smaller codecs into a larger one. In this case, we'll
+need one for each field:
+
+- a `Codec<Integer>`
+- a `Codec<Item>`
+- a `Codec<List<BlockPos>>`
+
+We can get the first one from the aforementioned primitive codecs in the `Codec` class, specifically `Codec.INT`. While
+the second one can be obtained from the `Registries.ITEM` registry, which has a `getCodec()` method that returns a 
+`Codec<Item>`. We don't have a default codec for `List<BlockPos>`, but we can make one from `BlockPos.CODEC`.
+
+### Lists
+
+`Codec#listOf` can be used to create a list version of any codec:
+
+```java
+Codec<List<BlockPos>> listCodec = BlockPos.CODEC.listOf();
+```
+
+It should be noted that codecs created in this way will always deserialize to an `ImmutableList`. If you need a mutable
+list instead, you can make use of [xmap](#mutually-convertible-types-and-you) to convert to one during
+deserialization.
+
+### Merging Codecs for Record-like Classes
+
+Now that we have separate codecs for each field, we can combine them into one codec for our class using
+a `RecordCodecBuilder`. This assumes that our class has a constructor containing every field we want to serialize, and
+that every field has a corresponding getter method. This makes it perfect to use in conjunction with records, but it can
+also be used with regular classes.
+
+Let's take a look at how to create a codec for our `CoolBeansClass`:
+
+```java
+public static final Codec<CoolBeansClass> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+    Codec.INT.fieldOf("beans_amount").forGetter(CoolBeansClass::getBeansAmount),
+    Registries.ITEM.getCodec().fieldOf("bean_type").forGetter(CoolBeansClass::getBeanType),
+    BlockPos.CODEC.listOf().fieldOf("bean_positions").forGetter(CoolBeansClass::getBeanPositions)
+    // Up to 16 fields can be declared here
+).apply(instance, CoolBeansClass::new));
+```
+
+Each line in the group specifies a codec, a field name, and a getter method. The `Codec#fieldOf` call is used to convert
+the codec into a [map codec](#mapcodec-not-to-be-confused-with-codecltmapgt), and the `forGetter` call specifies the getter 
+method used to retrieve the value of the field from an instance of the class. Meanwhile, the `apply` call specifies the 
+constructor used to create new instances. Note that the order of the fields in the group should be the same as the order 
+of the arguments in the constructor.
+
+You can also use `Codec#optionalFieldOf` in this context to make a field optional, as explained in
+the [Optional Fields](#optional-fields) section.
+
+### MapCodec, not to be confused with Codec&lt;Map&gt;
+
+Calling `Codec#fieldOf` will convert a `Codec<T>` into a `MapCodec<T>`, which is a variant, but not direct
+implementation of `Codec<T>`. It essentially boxes the value of the source codec inside a map, with the given field name
+as the key. For example, a `Codec<BlockPos>` when serialized into json would look like this:
+
+```json
+[1, 2, 3]
+```
+
+But when converted into a `MapCodec<BlockPos>` using `BlockPos.CODEC.fieldOf("pos")`, it would look like this:
+
+```json
+{
+  "pos": [1, 2, 3]
+}
+```
+
+While the main use for map codecs is to be merged with other map codecs to construct a codec for a full class worth of
+fields, as explained in the [Merging Codecs for Record-like Classes](#merging-codecs-for-record-like-classes) section
+above, they can also be turned back into regular codecs using `MapCodec#codec`, which will retain the same behavior of
+boxing their input value.
+
+#### Optional Fields
+
+`Codec#optionalFieldOf` can be used to create an optional map codec. This will, when the specified field is not present
+in the container during deserialization, either be deserialized as an empty `Optional` or a specified default value.
+
+```java
+// Without a default value
+MapCodec<Optional<BlockPos>> optionalCodec = BlockPos.CODEC.optionalFieldOf("pos");
+
+// With a default value
+MapCodec<BlockPos> optionalCodec = BlockPos.CODEC.optionalFieldOf("pos", BlockPos.ORIGIN);
+```
+
+Do note that optional fields will silently ignore any errors that may occur during deserialization. This means that if
+the field is present, but the value is invalid, the field will always be deserialized as the default value.
+
+### Constants, Constraints, and Composition
+
+#### Unit
+
+`Codec.unit` can be used to create a codec that always deserializes to a constant value, regardless of the input. When
+serializing, it will do nothing.
+
+```java
+Codec<Integer> theMeaningOfCodec = Codec.unit(42);
+```
+
+#### Numeric Ranges
+
+`Codec.intRange` and its pals, `Codec.floatRange` and `Codec.doubleRange` can be used to create a codec that only 
+accepts number values within a specified **inclusive** range. This applies to both serialization and deserialization.
+
+```java
+// Can't be more than 2
+Codec<Integer> amountOfFriendsYouHave = Codec.intRange(0, 2);
+```
+
+#### Pair
+
+`Codec.pair` merges two codecs, `Codec<A>` and `Codec<B>`, into a `Codec<Pair<A, B>>`. Keep in mind it only works 
+properly with codecs that serialize to a specific field, such as 
+[converted `MapCodec`s](#mapcodec-not-to-be-confused-with-codecltmapgt) or 
+[record codecs](#merging-codecs-for-record-like-classes). 
+The resulting codec will serialize to a map combining the fields of both codecs used.
+
+For example, running this code:
+
+```java
+// Create two seperate boxed codecs
+MapCodec<Integer> firstCodec = Codec.INT.fieldOf("i_am_number").codec();
+MapCodec<Boolean> secondCodec = Codec.BOOL.fieldOf("this_statement_is_false").codec();
+
+// Merge them into a pair codec
+Codec<Pair<Integer, Boolean>> pairCodec = Codec.pair(firstCodec, secondCodec);
+
+// Use it to serialize data
+DataResult<JsonElement> result = pairCodec.encodeStart(JsonOps.INSTANCE, Pair.of(23, true)).
+```
+
+Will output this json:
+
+```json
+{
+  "i_am_number": 23,
+  "this_statement_is_false": true
+}
+```
+
+#### Either
+
+`Codec.either` combines two codecs, `Codec<A>` and `Codec<B>`, into a `Codec<Either<A, B>>`. The resulting codec will,
+during both *serialization and deserialization*, attempt to use the first codec, and *only if that fails*, 
+attempt to use the second one. If the second one also fails, the error of the *second* codec will be returned.
+
+#### Maps
+
+For processing maps with arbitrary keys, such as `HashMap`s, `Codec.unboundedMap` can be used. This returns a
+`Codec<Map<K, V>>` for a given `Codec<K>` and `Codec<V>`. The resulting codec will serialize to a json object or 
+whatever equivalent is available for the current dynamic ops.
+
+Due to limitations of json and nbt, the key codec used must serialize to a string. This includes codecs for types that
+aren't strings themselves, but do serialize to them, such as `Identifier.CODEC`. See the example below:
+
+```java
+// Create a codec for a map of identifiers to integers
+Codec<Map<Identifier, Integer>> mapCodec = Codec.unboundedMap(Identifier.CODEC, Codec.INT);
+
+// Use it to serialize data
+DataResult<JsonElement> result = mapCodec.encodeStart(JsonOps.INSTANCE, Map.of(
+    new Identifier("example", "number"), 23,
+    new Identifier("example", "the_cooler_number"), 42
+));
+```
+
+This will output this json:
+
+```json
+{
+  "example:number": 23,
+  "example:the_cooler_number": 42
+}
+```
+
+As you can see, this works because `Identifier.CODEC` serializes directly to a string value. A similar effect can be 
+achieved for simple objects that don't serialize to strings by using [xmap & friends](#mutually-convertible-types-and-you) to 
+convert them.
+
+### Mutually Convertible Types and You
+
+#### xmap
+
+Say we have two classes that can be converted to each other, but don't have a parent-child relationship. For example,
+a vanilla `BlockPos` and `Vec3d`. If we have a codec for one, we can use `Codec#xmap` to create a codec for the other by
+specifying a conversion function for each direction.
+
+`BlockPos` already has a codec, but let's pretend it doesn't. We can create one for it by basing it on the
+codec for `Vec3d` like this:
+
+```java
+Codec<BlockPos> blockPosCodec = Vec3d.CODEC.xmap(
+    // Convert Vec3d to BlockPos
+    vec -> new BlockPos(vec.x, vec.y, vec.z),
+    // Convert BlockPos to Vec3d
+    pos -> new Vec3d(pos.getX(), pos.getY(), pos.getZ())
+);
+
+// It'd be cleaner to use method references to helper functions to transform 
+// between the two, but this is just an example
+```
+
+#### flatComapMap, comapFlatMap, and flatXMap
+
+`Codec#flatComapMap`, `Codec#comapFlatMap` and `flatXMap` are similar to xmap, but they allow one or both of the 
+conversion functions to return a DataResult. This is useful in practice because a specific object instance may not 
+always be valid for conversion. 
+
+Take for example vanilla `Identifier`s. Not all strings are valid identifiers, so using xmap would mean throwing ugly 
+exceptions when the conversion fails. However, its codec is actually a `comapFlatMap` on `Codec.STRING`, nicely
+illustrating how to use it:
+
+```java
+public class Identifier {
+    public static final Codec<Identifier> CODEC = Codec.STRING.comapFlatMap(
+        Identifier::validate, Identifier::toString
+    );
+
+    // ...
+
+    public static DataResult<Identifier> validate(String id) {
+        try {
+            return DataResult.success(new Identifier(id));
+        } catch (InvalidIdentifierException e) {
+            return DataResult.error("Not a valid resource location: " + id + " " + e.getMessage());
+        }
+    }
+    
+    // ...
+}
+```
+
+While these methods are really helpful, their names are a bit confusing, so here's a table to help you remember which 
+one to use:
+
+| Method                  | A -> B always valid? | B -> A always valid? |
+| ----------------------- | -------------------- | -------------------- |
+| `Codec<A>#xmap`         | Yes                  | Yes                  |
+| `Codec<A>#comapFlatMap` | No                   | Yes                  |
+| `Codec<A>#flatComapMap` | Yes                  | No                   |
+| `Codec<A>#flatXMap`     | No                   | No                   |
+
+### Registry Dispatch
+
+`Codec#dispatch` let us define a registry of codecs and dispatch to a specific one based on the value of a 
+field in the serialized data. This is very useful when deserializing objects that have different fields depending on
+their type, but still represent the same thing.
+
+For example, say we have an abstract `Bean` class with two subclasses: `StringyBean` and `CountingBean`. To serialize
+these with a registry dispatch, we'll need a few things:
+
+- Separate codecs for every type of bean.
+- A `BeanType` interface or class that represents the type of bean, and can return the codec for it.
+- A function on `Bean` to retrieve its `BeanType`.
+- A map or registry to map `Identifier`s to `BeanType`s.
+- A `Codec<BeanType>` based on this registry. If you used a `net.minecraft.registry.Registry`, one can be easily made 
+  using `Registry#getCodec`.
+
+With all of this, we can create a registry dispatch codec for beans:
+
+```java
+class Bean {
+    // ...
+    public BeanType getType() {
+        // ...
+    }
+}
+
+class BeanType {
+    // ...
+    
+    public Codec<? extends Bean> getCodec();
+}
+
+class StringyBean extends Bean {
+    public static final Codec<StringyBean> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+        Codec.STRING.fieldOf("stringy_string").forGetter(StringyBean::getStringyString)
+    ).apply(instance, StringyBean::new));
+
+    public final String stringyString;
+
+    // ...
+}
+
+class CountingBean extends Bean {
+    public static final Codec<CountingBean> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+        Codec.INT.fieldOf("counting_number").forGetter(CountingBean::getCountingNumber)
+    ).apply(instance, CountingBean::new));
+
+    public final int countingNumber;
+
+    // ...
+}
+
+// Create a registry to map identifiers to bean types
+Registry<BeanType> beanTypeRegistry = new SimpleRegistry<>(new Identifier("example", "bean_types"), Lifecycle.stable());
+
+// Register the bean types
+beanTypeRegistry.register(new Identifier("example", "stringy_bean"), new BeanType(StringyBean.CODEC));
+beanTypeRegistry.register(new Identifier("example", "counting_bean"), new BeanType(CountingBean.CODEC));
+
+// Create a codec for bean types
+Codec<BeanType> beanTypeCodec = beanTypeRegistry.getCodec();
+
+// And here's our registry dispatch codec for beans! 
+// The first argument is the field name for the bean type
+Codec<Bean> beanCodec = beanTypeCodec.dispatch("type", Bean::getType, BeanType::getCodec);
+```
+
+This will serialize beans to json like this, grabbing only fields that are relevant to its type:
+
+```json
+{
+  "type": "example:stringy_bean",
+  "stringy_string": "This bean is stringy!"
+}
+```
+
+```json
+{
+  "type": "example:counting_bean",
+  "counting_number": 42
+}
+```
+
+## References
+
+- A much more comprehensive documentation of codecs and related APIs can be found at the
+  [Unofficial DFU JavaDoc](https://kvverti.github.io/Documented-DataFixerUpper/snapshot/com/mojang/serialization/Codec.html).
+- The general structure of this guide was heavily inspired by the
+  [Forge Community Wiki's page on codecs](https://forge.gemwire.uk/wiki/Codecs), a more Forge-specific take on the same
+  topic.
\ No newline at end of file
diff --git a/misc-topics/index.md b/misc-topics/index.md
new file mode 100644
index 0000000..d1b353a
--- /dev/null
+++ b/misc-topics/index.md
@@ -0,0 +1,11 @@
+---
+title: Miscellaneous Topics
+prev: false
+next: false
+---
+
+# Miscellaneous Topics - About This Section
+
+The miscellaneous topics section contains a variety of topics that don't fit into any other category, or are too small to warrant their own section but are still considered worthy of being documented on the wiki.
+
+These topics are not ordered in any particular way, and can be read in any order, and usually aren't version specific.
\ No newline at end of file
diff --git a/misc-topics/text-and-translations.md b/misc-topics/text-and-translations.md
new file mode 100644
index 0000000..61bc30c
--- /dev/null
+++ b/misc-topics/text-and-translations.md
@@ -0,0 +1,124 @@
+---
+title: Text and Translations
+description: Comprehensive documentation for Minecraft's handling of formatted text and translations.
+prev: false
+next: false
+---
+
+<script setup>
+import ColorSwatch from '../components/ColorSwatch.vue';
+</script>
+
+# Text and Translations
+
+Whenever Minecraft displays text ingame, it's probably defined using a `Text` object.
+This custom type is used instead of a `String` to allow for more advanced formatting,
+including colors, boldness, obfuscation, and click events. They also allow easy access
+to the translation system, making it simple to translate any interface elements into
+different languages.
+
+If you've worked with datapacks or functions before, you may see parallels with the
+json text format used for displayNames, books, and signs among other things. As you
+can probably guess, this is just a json representation of a `Text` object, and can be
+converted to and from using `Text.Serializer`.
+
+When making a mod, it is generally preferred to construct your `Text` objects directly
+in code, making use of translations whenever possible.
+
+## Text literals
+
+The simplest way to create a `Text` object is to make a literal. This is just a string
+that will be displayed as-is, by default without any formatting.
+
+These are created using the `Text.of` or `Text.literal` methods, which both act slightly
+differently. `Text.of` accepts nulls as input, and will return a `Text` instance. In
+contrast, `Text.literal` should not be given a null input, but returns a `MutableText`,
+this being a subclass of `Text` that can be easily styled and concatenated. More about
+this later.
+
+```java
+Text literal = Text.of("Hello, world!");
+MutableText mutable = Text.literal("Hello, world!");
+// Keep in mind that a MutableText can be used as a Text, making this valid:
+Text mutableAsText = mutable;
+```
+
+## Translatable Text
+
+When you want to provide multiple translations for the same string of text, you can use the `Text.translatable` method to reference a translation key in any language file. If the key doesn't exist, the translation key is converted to a literal.
+
+```java
+Text translatable = Text.translatable("my_mod.text.hello");
+
+// Similarly to literals, translatable text can be easily made mutable.
+MutableText mutable = Text.translatable("my_mod.text.bye");
+```
+
+The language file, `en_us.json`, looks like the following:
+
+```json
+{
+  "my_mod.text.hello": "Hello!",
+  "my_mod.text.bye": "Goodbye :("
+}
+```
+
+## Serializing Text
+
+As mentioned before, you can serialize text to JSON using the `Text.Serializer` class:
+
+```java
+MutableText mutable = Text.translatable("my_mod.text.bye");
+String jsonString = Text.Serializer.toJson(mutable);
+```
+
+This produces JSON that can be used datapacks, commands and other places that accept the JSON format of text instead of literal or translatable text.
+
+## Deserializing Text
+
+Furthermore, to deserialize a JSON text object into an actual `Text` class, you can use the `fromJson` method:
+
+```java
+String jsonString = Text.Serializer.toJson(mutable);
+
+// Deserializing from JSON will always produce a mutable text object.
+MutableText result = Text.Serializer.fromJson(jsonString);
+```
+
+## Formatting
+
+You may be familiar with Minecraft's formatting standards:
+
+You can apply these formattings using the `Formatting` enum on the `MutableText` class:
+
+```java
+MutableText result = Text.literal("Hello World!")
+  .formatted(Formatting.AQUA, Formatting.BOLD, Formatting.UNDERLINE);
+```
+
+
+<table>
+    <tr><th>Color</th><th>Name</th><th>Chat Code</th><th>MOTD Code</th><th>Hex Code</th></tr>
+    <tr><td><ColorSwatch color="#000000" /></td><td>Black (black)</td><td>§0</td><td>\u00A70</td><td>#000000</td></tr>
+    <tr><td><ColorSwatch color="#0000AA" /></td><td>Dark Blue (dark_blue)</td><td>§1</td><td>\u00A71</td><td>#0000AA</td></tr>
+    <tr><td><ColorSwatch color="#00AA00" /></td><td>Dark Green (dark_green)</td><td>§2</td><td>\u00A72</td><td>#00AA00</td></tr>
+    <tr><td><ColorSwatch color="#00AAAA" /></td><td>Dark Aqua (dark_aqua)</td><td>§3</td><td>\u00A73</td><td>#00AAAA</td></tr>
+    <tr><td><ColorSwatch color="#AA0000" /></td><td>Dark Red (dark_red)</td><td>§4</td><td>\u00A74</td><td>#AA0000</td></tr>
+    <tr><td><ColorSwatch color="#AA00AA" /></td><td>Dark Purple (dark_purple)</td><td>§5</td><td>\u00A75</td><td>#AA00AA</td></tr>
+    <tr><td><ColorSwatch color="#FFAA00" /></td><td>Gold (gold)</td><td>§6</td><td>\u00A76</td><td>#FFAA00</td></tr>
+    <tr><td><ColorSwatch color="#AAAAAA"/></td><td>Gray (gray)</td><td>§7</td><td>\u00A77</td><td>#AAAAAA</td></tr>
+    <tr><td><ColorSwatch color="#555555" /></td><td>Dark Gray (dark_gray)</td><td>§8</td><td>\u00A78</td><td>#555555</td></tr>
+    <tr><td><ColorSwatch color="#5555FF" /></td><td>Blue (blue)</td><td>§9</td><td>\u00A79</td><td>#5555FF</td></tr>
+    <tr><td><ColorSwatch color="#55FF55" /></td><td>Green (green)</td><td>§a</td><td>\u00A7a</td><td>#55FF55</td></tr>
+    <tr><td><ColorSwatch color="#55FFFF" /></td><td>Aqua (aqua)</td><td>§b</td><td>\u00A7b</td><td>#55FFFF</td></tr>
+    <tr><td><ColorSwatch color="#FF5555" /></td><td>Red (red)</td><td>§c</td><td>\u00A7c</td><td>#FF5555</td></tr>
+    <tr><td><ColorSwatch color="#FF55FF" /></td><td>Light Purple (light_purple)</td><td>§d</td><td>\u00A7d</td><td>#FF55FF</td></tr>
+    <tr><td><ColorSwatch color="#FFFF55" /></td><td>Yellow (yellow)</td><td>§e</td><td>\u00A7e</td><td>#FFFF55</td></tr>
+    <tr><td><ColorSwatch color="#FFFFFF" /></td><td>White (white)</td><td>§f</td><td>\u00A7f</td><td>#FFFFFF</td></tr>
+    <tr><td></td><td>Reset</td><td>§r</td><td></td><td></td></tr>
+    <tr><td></td><td>**Bold**</td><td>§l</td><td></td><td></td></tr>
+    <tr><td></td><td>~~Strikethrough~~</td><td>§m</td><td></td><td></td></tr>
+    <tr><td></td><td><u>Underline</u></td><td>§n</td><td></td><td></td></tr>
+    <tr><td></td><td>*Italic*</td><td>§o</td><td></td><td></td></tr>
+    <tr><td></td><td>Obfuscated</td><td>§k</td><td></td><td></td></tr>
+</table>
\ No newline at end of file