diff --git a/README.md b/README.md
index 4ec8997..2f498ce 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,8 @@ Open-source Implementation of the Java language in TypeScript. (<https://docs.or
   - [Table of Contents](#table-of-contents)
   - [Prerequisites](#prerequisites)
   - [Usage](#usage)
+  - [Current Features](#current-features)
+  - [Future Features](#future-features)
   - [Testing](#testing)
   - [Using your java-slang in Source Academy](#using-your-java-slang-in-source-academy)
   - [Using your java-slang in your local Source Academy](#using-your-java-slang-in-your-local-source-academy)
@@ -39,6 +41,26 @@ $ git submodule update --init --recursive
 $ git submodule update --recursive --remote
 ```
 
+## Current Features
+
+The Java language in Source Academy currently supports a host of available features, including:
+
+- Primitive classes: boolean, byte, short, int, long, char, float and double.
+- Custom (non-primitive) classes
+- Method overloading
+- Implicit type widening for both primitive and non-primitive types (e.g. int to long)
+- Basic exception/error messages
+- Basic system calls e.g. System.out.println
+- Explicit type conversion (type narrowing)
+- Implicit type conversion for system calls (e.g. int input to System.out.println)
+- Single nested class
+
+## Future Features
+
+- Multiple class declarations in the same file
+- Inheritance (basis for implementation exists but requires multiclass declaration to function)
+- Generics
+- Multi-file programs
 
 ## Testing
 
diff --git a/eslint.config.mjs b/eslint.config.mjs
new file mode 100644
index 0000000..17f865b
--- /dev/null
+++ b/eslint.config.mjs
@@ -0,0 +1,7 @@
+import markdown from "@eslint/markdown";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  { ignores: ["**/*.js", "**/*.cjs", "**/*.mjs"] },
+  { files: ["**/*.md"], plugins: { markdown }, language: "markdown/gfm" },
+]);
diff --git a/src/ast/types/blocks-and-statements.ts b/src/ast/types/blocks-and-statements.ts
index fe5dc7a..b5f9e9c 100644
--- a/src/ast/types/blocks-and-statements.ts
+++ b/src/ast/types/blocks-and-statements.ts
@@ -259,7 +259,14 @@ export interface Assignment extends BaseNode {
 }
 
 export type LeftHandSide = ExpressionName | ArrayAccess;
-export type UnaryExpression = PrefixExpression | PostfixExpression;
+export type UnaryExpression = PrefixExpression | PostfixExpression | CastExpression;
+
+export interface CastExpression extends BaseNode {
+  kind: "CastExpression";
+  castType: Identifier;
+  expression: Expression;
+  isPrimitiveCast: boolean;
+}
 
 export interface PrefixExpression extends BaseNode {
   kind: "PrefixExpression";
diff --git a/src/compiler/README.md b/src/compiler/README.md
index a184cd4..c63de65 100644
--- a/src/compiler/README.md
+++ b/src/compiler/README.md
@@ -1,5 +1,7 @@
 This is a bookkeeping of the planned scope of the compiler. It will be updated from time to time to reflect the current status of the compiler and to make the scope clearer. For a more formal treatment of what features are being supported, see scope.txt for a BNF-form of the Java sub-language.
 
+Note that the compiler is separate from the Java Playground in the online version of Source Academy, which runs in tandem with the ECE. As such, any program run in the Playground will follow the features implemented in the ECE (e.g. widening type conversions), rather than the features below.
+
 **Features that are already supported**
 
 - Single source file, single public class, with exactly one main method
@@ -12,21 +14,26 @@ This is a bookkeeping of the planned scope of the compiler. It will be updated f
 - Method invocation
 - Non-static import statements
 - Single dimension array declaration/initialization
-
-**Features that are planned to support**
-
-- Class fields (with `public static` access flag)
 - Primitive type variables
+- Class fields (with `public static` access flag)
 - Object instantiation (with `new` keyword)
+- Instance fields/methods
+- Class inheritance
+- Method overloading/overriding
+- Type casting
+
 
-**Features that will not be supported**
+**Features that can possibly be supported in the future**
 
 - Annotations
 - Multiple files, modules, packages
-- Instance fields/methods
 - Interfaces
-- Class inheritance
-- Method overloading/overriding
 - Generics
-- Type casting
+- Exceptions
+
 
+**Testing**
+Unit tests are located in the "__tests__/tests" folder. The main testing file is "__tests__/index.ts", in which the tests to be run can be specified. To run, navigate to the main java-slang folder and run:
+```bash
+$ yarn test src/compiler/__tests__/index.ts
+```
\ No newline at end of file
diff --git a/src/compiler/__tests__/index.ts b/src/compiler/__tests__/index.ts
index 8f31ef5..c6de94a 100644
--- a/src/compiler/__tests__/index.ts
+++ b/src/compiler/__tests__/index.ts
@@ -9,17 +9,19 @@ import { methodInvocationTest } from "./tests/methodInvocation.test";
 import { importTest } from "./tests/import.test";
 import { arrayTest } from "./tests/array.test";
 import { classTest } from "./tests/class.test";
+import { typeConversionTest } from "./tests/typeConversion.test";
 
 describe("compiler tests", () => {
   printlnTest();
   variableDeclarationTest();
   arithmeticExpressionTest();
-  unaryExpressionTest();
   ifElseTest();
   whileTest();
   forTest();
+  unaryExpressionTest();
   methodInvocationTest();
   importTest();
   arrayTest();
   classTest();
+  typeConversionTest();
 })
\ No newline at end of file
diff --git a/src/compiler/__tests__/tests/typeConversion.test.ts b/src/compiler/__tests__/tests/typeConversion.test.ts
new file mode 100644
index 0000000..de3ae73
--- /dev/null
+++ b/src/compiler/__tests__/tests/typeConversion.test.ts
@@ -0,0 +1,27 @@
+import {
+  runTest,
+  testCase,
+} from "../__utils__/test-utils";
+
+const testCases: testCase[] = [
+  {
+    comment: "int to float widening type",
+    program: `
+      public class Main {
+        public static void main(String[] args) {
+          float f = 1.0f;
+          int x = (int) f;
+          System.out.println(x);
+        }
+      }
+    `,
+    expectedLines: ["1"],
+  }
+];
+
+export const typeConversionTest = () => describe("type conversion", () => {
+  for (let testCase of testCases) {
+    const { comment: comment, program: program, expectedLines: expectedLines } = testCase;
+    it(comment, () => runTest(program, expectedLines));
+  }
+});
diff --git a/src/compiler/code-generator.ts b/src/compiler/code-generator.ts
index 1b0d8c8..63eb288 100644
--- a/src/compiler/code-generator.ts
+++ b/src/compiler/code-generator.ts
@@ -24,7 +24,8 @@ import {
   ClassInstanceCreationExpression,
   ExpressionStatement,
   TernaryExpression,
-  LeftHandSide
+  LeftHandSide,
+  CastExpression
 } from '../ast/types/blocks-and-statements'
 import { MethodDeclaration, UnannType } from '../ast/types/classes'
 import { ConstantPoolManager } from './constant-pool-manager'
@@ -516,6 +517,79 @@ const codeGenerators: { [type: string]: (node: Node, cg: CodeGenerator) => Compi
     return f(node, cg.labels[cg.labels.length - 1], false)
   },
 
+  CastExpression: (node: Node, cg: CodeGenerator) => {
+    const { castType: ct,  expression: expr, isPrimitiveCast: b } = node as CastExpression
+    if (b) {
+      const res = compile(expr, cg)
+      const { stackSize: size, resultType: rt } = res
+      switch (ct) {
+        case 'double':
+          switch (rt) {
+            case 'F':
+              cg.code.push(OPCODE.F2D)
+              break
+            case 'J':
+              cg.code.push(OPCODE.L2D)
+              break
+            case 'I':
+              cg.code.push(OPCODE.I2D)
+              break
+            default:
+              break
+          }
+          return { stackSize: Math.max(size, 2), resultType: 'D' }
+        case 'float':
+          switch(rt) {
+            case 'D':
+              cg.code.push(OPCODE.D2F)
+              break
+            case 'J':
+              cg.code.push(OPCODE.L2F)
+              break
+            case 'I':
+              cg.code.push(OPCODE.I2F)
+              break
+            default:
+          }
+          return { stackSize: Math.max(size, 1), resultType: 'F' }
+        case 'long':
+          switch(rt) {
+            case 'D':
+              cg.code.push(OPCODE.D2L)
+              break
+            case 'F':
+              cg.code.push(OPCODE.F2L)
+              break
+            case 'I':
+              cg.code.push(OPCODE.I2L)
+              break
+            default:
+              break
+          }
+          return { stackSize: Math.max(size, 2), resultType: 'L' }
+        case 'int':
+          switch (rt) {
+            case 'D':
+              cg.code.push(OPCODE.D2I)
+              break
+            case 'F':
+              cg.code.push(OPCODE.F2I)
+              break
+            case 'J':
+              cg.code.push(OPCODE.L2I)
+              break
+            default:
+              break
+          }
+          return { stackSize: Math.max(size, 1), resultType: 'I' }
+      }
+    }
+    const res = compile(expr, cg);
+    const classInfoIndex = cg.constantPoolManager.indexClassInfo(ct as string);
+    cg.code.push(OPCODE.CHECKCAST, 0, classInfoIndex);
+    return res;
+  },
+
   ClassInstanceCreationExpression: (node: Node, cg: CodeGenerator) => {
     const { identifier: id, argumentList: argLst } = node as ClassInstanceCreationExpression
     let maxStack = 2
diff --git a/src/compiler/grammar.ts b/src/compiler/grammar.ts
index 4b6f1ee..013d564 100755
--- a/src/compiler/grammar.ts
+++ b/src/compiler/grammar.ts
@@ -1109,8 +1109,22 @@ PostfixExpression
   }
 
 CastExpression
-  = lparen PrimitiveType rparen UnaryExpression
-  / lparen ReferenceType rparen (LambdaExpression / !(PlusMinus) UnaryExpression)
+  = lparen t:PrimitiveType rparen expr:UnaryExpression {
+    return addLocInfo({
+      kind: "CastExpression",
+      castType: t,
+      expression: expr,
+      isPrimitiveCast: true,
+    });
+  }
+  / lparen t:ReferenceType rparen expr:(LambdaExpression / !(PlusMinus) UnaryExpression) {
+    return addLocInfo({
+      kind: "CastExpression",
+      castType: t,
+      expression: expr,
+      isPrimitiveCast: false,
+    });
+  }
 
 SwitchExpression
   = SwitchStatement
diff --git a/src/types/ast/utils.ts b/src/types/ast/utils.ts
index 1a703b7..f00fa7f 100644
--- a/src/types/ast/utils.ts
+++ b/src/types/ast/utils.ts
@@ -1,5 +1,6 @@
 import { IToken } from 'java-parser'
 import {
+  ArrayType,
   ClassOrInterfaceType,
   Dim,
   Identifier,
@@ -67,9 +68,11 @@ export const isIdentifier = (object: Record<string, any>): boolean => {
  * @deprecated
  */
 export const unannTypeToString = (
-  type: LocalVariableType | ClassOrInterfaceType | Result
+  type: LocalVariableType | ClassOrInterfaceType | ArrayType | Result
 ): string => {
   switch (type.kind) {
+    case 'ArrayType':
+      return unannTypeToString(type.type) + '[]'.repeat(type.dims.dims.length)
     case 'Boolean':
       return 'boolean'
     case 'FloatingPointType':
diff --git a/src/types/checker/index.ts b/src/types/checker/index.ts
index 005286e..43c6ffc 100644
--- a/src/types/checker/index.ts
+++ b/src/types/checker/index.ts
@@ -192,6 +192,34 @@ export const typeCheckBody = (node: Node, frame: Frame = Frame.globalFrame()): R
     case 'BreakStatement': {
       return OK_RESULT
     }
+    case 'CastExpression': {
+      let castTypeNode, expressionNode;
+      if ('primitiveType' in node) {
+        castTypeNode = node.primitiveType;
+        expressionNode = node.unaryExpression;
+      } else if ('referenceType' in node && 'unaryExpressionNotPlusMinus' in node) {
+        castTypeNode = node.referenceType;
+        expressionNode = node.unaryExpressionNotPlusMinus;
+      } else if ('referenceType' in node && 'lambdaExpression' in node) {
+        castTypeNode = node.referenceType;
+        expressionNode = node.lambdaExpression;
+      } else {
+        throw new Error('Invalid typecast.');
+      }
+
+      const castType = frame.getType(unannTypeToString(castTypeNode), castTypeNode.location);
+      if (castType instanceof TypeCheckerError) return newResult(null, [castType]);
+
+      const { currentType, errors } = typeCheckBody(expressionNode, frame);
+      if (errors.length > 0) return newResult(null, errors);
+      if (!currentType) throw new Error('Target of cast expression should return a type.');
+
+      if (!castType.canBeAssigned(currentType) && !currentType.canBeAssigned(castType)) {
+        return newResult(null, [new IncompatibleTypesError(node.location)]);
+      }
+
+      return newResult(castType);
+    }
     case 'ClassInstanceCreationExpression': {
       const classIdentifier =
         node.unqualifiedClassInstanceCreationExpression.classOrInterfaceTypeToInstantiate