diff --git a/src/main/java/java/io/Serial.java b/src/main/java/java/io/Serial.java
new file mode 100644
index 0000000..9b6b883
--- /dev/null
+++ b/src/main/java/java/io/Serial.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+package java.io;
+
+import java.lang.annotation.*;
+
+/**
+ * Indicates that an annotated field or method is part of the {@linkplain
+ * Serializable serialization mechanism} defined by the
+ * <a href="{@docRoot}/../specs/serialization/output.html">
+ * <cite>Java Object Serialization Specification</cite></a>. This
+ * annotation type is intended to allow compile-time checking of
+ * serialization-related declarations, analogous to the checking
+ * enabled by the {@link java.lang.Override} annotation type to
+ * validate method overriding. {@code Serializable} classes are encouraged to
+ * use {@code @Serial} annotations to help a compiler catch
+ * mis-declared serialization-related fields and methods,
+ * mis-declarations that may otherwise be difficult to detect.
+ *
+ * <p>Specifically, annotations of this type should be
+ * applied to serialization-related methods and fields in classes
+ * declared to be {@code Serializable}. The five serialization-related
+ * methods are:
+ *
+ * <ul>
+ * <li>{@code private void writeObject(java.io.ObjectOutputStream stream) throws IOException}
+ * <li>{@code private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException}
+ * <li>{@code private void readObjectNoData() throws ObjectStreamException}
+ * <li><i>ANY-ACCESS-MODIFIER</i> {@code Object writeReplace() throws ObjectStreamException}
+ * <li><i>ANY-ACCESS-MODIFIER</i> {@code Object readResolve() throws ObjectStreamException}
+ * </ul>
+ *
+ * The two serialization-related fields are:
+ *
+ * <ul>
+ * <li>{@code private static final ObjectStreamField[] serialPersistentFields}
+ * <li>{@code private static final long serialVersionUID}
+ * </ul>
+ *
+ * Compilers are encouraged to validate that a method or field marked with a
+ * {@code @Serial} annotation is one of the defined serialization-related
+ * methods or fields declared in a meaningful context and issue a warning
+ * if that is not the case.
+ *
+ * <p>It is a semantic error to apply this annotation to other fields or methods, including:
+ * <ul>
+ * <li>fields or methods in a class that is not {@code Serializable}
+ *
+ * <li>fields or methods of the proper structural declaration, but in
+ * a type where they are ineffectual. For example, {@code enum} types
+ * are defined to have a {@code serialVersionUID} of {@code 0L} so a
+ * {@code serialVersionUID} field declared in an {@code enum} type is
+ * ignored. The five serialization-related methods identified above
+ * are likewise ignored for an {@code enum} type.
+ *
+ * <li>in a class that is {@code Externalizable}:
+ * <ul>
+ *   <li> method declarations of {@code writeObject}, {@code
+ *   readObject}, and {@code readObjectNoData}
+ *
+ *  <li>a field declaration for {@code serialPersistentFields}
+ * </ul>
+ *
+ * While the {@code Externalizable} interface extends {@code
+ * Serializable}, the three methods and one field above are
+ * <em>not</em> used for externalizable classes.
+ *
+ * </ul>
+ *
+ * Note that serialization mechanism accesses its designated fields
+ * and methods reflectively and those fields and methods may appear
+ * otherwise unused in a {@code Serializable} class.
+ *
+ * @spec serialization/index.html Java Object Serialization Specification
+ * @see Serializable
+ * @see Externalizable
+ * @since 14
+ */
+@Target({ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.SOURCE)
+public @interface Serial {}
diff --git a/src/main/java/java/lang/reflect/InaccessibleObjectException.java b/src/main/java/java/lang/reflect/InaccessibleObjectException.java
new file mode 100644
index 0000000..810f296
--- /dev/null
+++ b/src/main/java/java/lang/reflect/InaccessibleObjectException.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+package java.lang.reflect;
+
+/**
+ * Thrown when Java language access checks cannot be suppressed.
+ *
+ * @see AccessibleObject#setAccessible(boolean)
+ * @since 9
+ */
+
+public class InaccessibleObjectException extends RuntimeException {
+    @java.io.Serial
+    private static final long serialVersionUID = 4158786093378140901L;
+
+    /**
+     * Constructs an {@code InaccessibleObjectException} with no detail message.
+     */
+    public InaccessibleObjectException() {
+    }
+
+    /**
+     * Constructs an {@code InaccessibleObjectException} with the given detail
+     * message.
+     *
+     * @param msg
+     *        The detail message
+     */
+    public InaccessibleObjectException(String msg) {
+        super(msg);
+    }
+
+}
diff --git a/src/main/java/me/finn/unlegitlibrary/utils/Logger.java b/src/main/java/me/finn/unlegitlibrary/utils/Logger.java
index 9d0331d..87e41f3 100644
--- a/src/main/java/me/finn/unlegitlibrary/utils/Logger.java
+++ b/src/main/java/me/finn/unlegitlibrary/utils/Logger.java
@@ -12,6 +12,7 @@ import java.awt.event.ActionListener;
 import java.io.*;
 import java.lang.reflect.Field;
 import java.lang.System;
+import java.lang.reflect.InaccessibleObjectException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -29,10 +30,16 @@ public final class Logger {
 
     private boolean isInitialized = false;
 
-    public Logger(File logFolder, boolean addShutdownHook) throws IOException, NoSuchFieldException, IllegalAccessException {
-        Field field = Charset.class.getDeclaredField("defaultCharset");
-        field.setAccessible(true);
-        field.set(null, StandardCharsets.UTF_8);
+    public Logger(File logFolder, boolean changeCharset, boolean addShutdownHook) throws IOException, NoSuchFieldException, IllegalAccessException {
+        if (changeCharset) {
+            try {
+                Field field = Charset.class.getDeclaredField("defaultCharset");
+                field.setAccessible(true);
+                field.set(null, StandardCharsets.UTF_8);
+            } catch (IllegalAccessException | InaccessibleObjectException exception) {
+                exception.printStackTrace();
+            }
+        }
 
         System.setProperty("client.encoding.override", "UTF-8");
         System.setProperty("file.encoding", "UTF-8");