diff --git a/docs/8.-Shared-Token-Types.md b/docs/8.-Shared-Token-Types.md
new file mode 100644
index 000000000..446786eff
--- /dev/null
+++ b/docs/8.-Shared-Token-Types.md
@@ -0,0 +1,320 @@
+Shared token types enable comparisons between languages
+
+Examples are given in a pseudo language similar to Java or Cpp
+
+# The Imperative paradigm
+
+## Variables
+
+Variable definition:
+```
+def x: Int
+| VAR_DEF
+```
+
+Variable definition with assignment:
+```
+def x: Int = 2
+| VAR_DEF
+           | ASSIGN
+```
+
+Assignment:
+```
+x = 3
+  | ASSIGN
+```
+
+## Types
+
+Structure definition:
+```
+type Name {
+| STRUCT_DEF
+    firstName: String
+    | STRUCT_MEMBER
+    lastName: String
+    | STRUCT_MEMBER
+}
+| STRUCT_END
+```
+
+## Control Structures
+
+If else:
+```
+if (...) {
+| IF
+...
+} else {
+  | ELSE
+...
+}
+| IF_END
+```
+
+If without else:
+```
+if(...) {
+| IF
+}
+| IF_END
+```
+
+Switch-case:
+```
+switch(...) {
+| SWITCH
+    case a: {
+    | CASE
+        ...
+    }
+    | CASE_END
+    case b: {
+    | CASE
+        ...
+    }
+    | CASE_END
+}
+```
+
+Switch-case with joined-cases (like in Java):
+```
+switch(...) {
+|SWITCH
+    case a:
+    | CASE
+    case b: {
+    | CASE
+        ...
+    }
+    | CASE_END
+}
+| SWITCH_END
+```
+
+Languages that require an explicit break to end the case clause should extract the CASE_END token on the break.
+
+
+
+While-loop:
+```
+while(...) {
+| LOOP
+      | <potential tokens in condition>
+    ....
+}
+| LOOP_END
+```
+
+For-loop:
+```
+for(def x: Int = 0; x < y; x++) {
+| LOOP
+                    | <potential tokens in condition>
+        | VAR_DEF
+               | ASSIGN
+        ...
+                           | <potential tokens in increment>
+}
+| LOOP_END
+```
+The order of the tokens is the order of the lines here. It is intentionally different from the appearance in the code to be compatible to the while loop
+
+For-each:
+```
+for i in <list> {
+| LOOP
+    | VAR_DEF
+          | <potential tokens in list creation>        
+    ....
+}
+| LOOP_END
+```
+
+Goto:
+```
+goto <label>
+|GOTO
+```
+
+Break:
+```
+break
+| BREAK
+```
+
+Continue:
+```
+continue
+| CONTINUE
+```
+
+Functions:
+```
+<modifier> function doSomething(parameter: Int): Int {
+           | FUNCTION           | VAR_DEF
+    ...
+    return 1
+    | RETURN
+}
+| FUNCTION_END
+```
+Modifiers and other features should be ignored here. All different kinds of functions (procedure, methods, functions, ...) Should be treated the same
+
+Function call:
+```
+doSomething(1)
+| CALL
+
+myObject.doSomething(1)
+         | CALL
+```
+
+## Exception Handling
+
+Throw:
+```
+throw <exception value>
+|THROW
+      | <potential tokens for value>
+```
+
+
+Try-Catch:
+```
+try {
+| TRY
+    ...
+}
+catch(e: Error1) {
+| CATCH
+    ...
+}
+catch(e: Error2) {
+| CATCH
+    ...
+}
+finally {
+| FINALLY
+}
+|TRY_END
+```
+There is no token for the error variable declaration, since it always has to be there and to be as language independent as possible
+
+# Object Orientation
+
+## Class / Interface definitions
+
+To maintain compatibility with other languages, all object-oriented types (enum, class, interface, abstract class, record, etc.) should be treated the same:
+
+```
+class MyClass extends MyInterface {
+| STRUCT_DEF
+    def attribute: Int
+    | STRUCT_MEMBER
+
+    function MyClass() {
+    | CONST
+        ...
+    }
+    | CONT_END
+    
+    function memberFunction(): Int {
+    | METHOD
+        ...
+    }
+    | METHOD_END
+}
+| STRUCT_END
+```
+
+## Object creation
+
+```
+def object: MyClass = new MyClass()
+|VAR_DEF
+                    | ASSIGN
+                      | NEW
+```
+
+# Code structure
+
+```
+package my_package
+| CONTEXT
+
+import other_package
+| IMPORT
+```
+
+```
+namespace {
+| CONTEXT
+}
+```
+
+Since JPlag doesn't care about the contents of a namespace or package, it's end isn't actually relevant. The only relevant thing is that it is declared.
+
+# Assert
+
+```
+assert 1 < 2
+| ASSERT
+```
+
+# Annotations
+
+```
+@MyAnnotation
+| ANNOTATION
+function myFunction(@NotNull param: Int) {
+| FUNCTION
+                    | ANNOTATION
+                             | VAR_DEF
+    ...
+}
+| FUNCTION_END
+```
+
+The annotation token should always appear before the annotated structure
+
+# Arrays
+
+```
+def x: Int[] = new Int[1]
+               | ARRAY_NEW
+               
+def x: Int[] = new Int[]{1}
+               | ARRAY_NEW
+                        | ARRAY_INIT_START
+                          | ARRAY_INIT_END
+```
+
+# Changes with attributes
+
+```
+class X {
+| (STRUCT_DEF, CLASS_DEF)
+}
+| (STRUCT_END, CLASS_END)
+```
+
+Other types (enum, union, record) follow suit
+
+```
+assert 1 < 2
+| (CALL, ASSERT)
+```
+
+```
+def x: Int[] = new Int[]{1}
+               | (ARRAY_NEW, NEW)
+                        | ARRAY_INIT_START
+                          | ARRAY_INIT_END
+```
+
+# TODO
+
+Synchronized-Syntax
+Modules
\ No newline at end of file
diff --git a/language-api/src/main/java/de/jplag/tokentypes/AnnotationTokenTypes.java b/language-api/src/main/java/de/jplag/tokentypes/AnnotationTokenTypes.java
new file mode 100644
index 000000000..3d5b07548
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/AnnotationTokenTypes.java
@@ -0,0 +1,18 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum AnnotationTokenTypes implements TokenType {
+    ANNOTATION("ANNO");
+
+    private String description;
+
+    AnnotationTokenTypes(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/ArraySyntaxTokenTypes.java b/language-api/src/main/java/de/jplag/tokentypes/ArraySyntaxTokenTypes.java
new file mode 100644
index 000000000..3974be7c9
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/ArraySyntaxTokenTypes.java
@@ -0,0 +1,20 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum ArraySyntaxTokenTypes implements TokenType {
+    NEW_ARRAY("ARRAY_NEW"),
+    ARRAY_INITIALIZER_START("ARRAY_INIT_START"),
+    ARRAY_INITIALIZER_END("ARRAY_INIT_END"),;
+
+    private String description;
+
+    ArraySyntaxTokenTypes(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/AssertTokenTypes.java b/language-api/src/main/java/de/jplag/tokentypes/AssertTokenTypes.java
new file mode 100644
index 000000000..e68535ed5
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/AssertTokenTypes.java
@@ -0,0 +1,18 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum AssertTokenTypes implements TokenType {
+    ASSERT("ASSERT"),;
+
+    private String description;
+
+    AssertTokenTypes(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/CodeStructureTokenTypes.java b/language-api/src/main/java/de/jplag/tokentypes/CodeStructureTokenTypes.java
new file mode 100644
index 000000000..1883a4251
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/CodeStructureTokenTypes.java
@@ -0,0 +1,22 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+/**
+ * Contains token types for code structures like packages or namespaces
+ */
+public enum CodeStructureTokenTypes implements TokenType {
+    CONTEXT_DEFINITION("CONTEXT"),
+    IMPORT("IMPORT"),;
+
+    private String description;
+
+    CodeStructureTokenTypes(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/ExceptionHandlingTokenTypes.java b/language-api/src/main/java/de/jplag/tokentypes/ExceptionHandlingTokenTypes.java
new file mode 100644
index 000000000..e11f6b2f9
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/ExceptionHandlingTokenTypes.java
@@ -0,0 +1,22 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum ExceptionHandlingTokenTypes implements TokenType {
+    THROW("THROW"),
+    TRY("TRY"),
+    TRY_END("TRY_END"),
+    CATCH("CATCH"),
+    FINALLY("FINALLY");
+
+    private String description;
+
+    ExceptionHandlingTokenTypes(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/ImperativeTokenType.java b/language-api/src/main/java/de/jplag/tokentypes/ImperativeTokenType.java
new file mode 100644
index 000000000..3fc4dbc70
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/ImperativeTokenType.java
@@ -0,0 +1,41 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum ImperativeTokenType implements TokenType {
+    VARIABLE_DEFINITION("VAR_DEF"),
+    ASSIGNMENT("ASSIGN"),
+
+    STRUCTURE_DEFINITION("STRUCT_DEF"),
+    STRUCTURE_END("STRUCT_END"),
+    STRUCTURE_MEMBER("STRUCT_MEMBER"),
+
+    IF("IF"),
+    ELSE("ELSE"),
+    IF_END("IF_END"),
+    SWITCH("SWITCH"),
+    SWITCH_END("SWITCH_END"),
+    CASE("CASE"),
+    CASE_END("CASE_END"),
+    LOOP("LOOP"),
+    LOOP_END("LOOP_END"),
+    GOTO("GOTO"), // TODO different context?
+    BREAK("BREAK"),
+    CONTINUE("CONTINUE"),
+
+    FUNCTION_DEFINITION("FUNCTION_DEF"),
+    FUNCTION_END("FUNCTION_END"),
+    RETURN("RETURN"),
+    CALL("CALL");
+
+    private String description;
+
+    ImperativeTokenType(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}
diff --git a/language-api/src/main/java/de/jplag/tokentypes/ObjectOrientationTokens.java b/language-api/src/main/java/de/jplag/tokentypes/ObjectOrientationTokens.java
new file mode 100644
index 000000000..464ecf610
--- /dev/null
+++ b/language-api/src/main/java/de/jplag/tokentypes/ObjectOrientationTokens.java
@@ -0,0 +1,22 @@
+package de.jplag.tokentypes;
+
+import de.jplag.TokenType;
+
+public enum ObjectOrientationTokens implements TokenType {
+    CONSTRUCTOR("CONST"),
+    CONSTRUCTOR_END("CONT_END"),
+    METHOD("METHOD"),
+    METHOD_END("METHOD_END"),
+    NEW("NEW"),;
+
+    private String description;
+
+    ObjectOrientationTokens(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.description;
+    }
+}