diff --git a/.github/workflows/Techousecodeql.yml b/.github/workflows/Techousecodeql.yml
new file mode 100644
index 0000000..cd948d0
--- /dev/null
+++ b/.github/workflows/Techousecodeql.yml
@@ -0,0 +1,93 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '17 15 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      security-events: write
+      packages: read
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: java-kotlin
+          build-mode: manual
+        - language: javascript-typescript
+          build-mode: autobuild
+        - language: python
+          build-mode: autobuild
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v4
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+
+    # Setup Java runtime only when doing manual Java builds.
+    - name: Setup Java (for manual Java builds)
+      if: matrix.language == 'java-kotlin' && matrix.build-mode == 'manual'
+      uses: actions/setup-java@v3
+      with:
+        distribution: 'temurin'
+        java-version: '17'
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    - name: Run manual build steps
+      if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        set -euo pipefail
+        echo "Running manual build for language: ${{ matrix.language }}"
+        if [ "${{ matrix.language }}" = "java-kotlin" ]; then
+          # Prefer project wrappers if present
+          if [ -f ./mvnw ]; then
+            chmod +x ./mvnw
+            ./mvnw -B -DskipTests package
+          elif [ -f pom.xml ]; then
+            mvn -B -DskipTests package
+          elif [ -f ./gradlew ]; then
+            chmod +x ./gradlew
+            ./gradlew build -x test
+          elif [ -f build.gradle ]; then
+            gradle build -x test
+          else
+            echo "No Java build files found (pom.xml/build.gradle or wrapper). Add build files or update workflow with correct build steps."
+            exit 1
+          fi
+        fi
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v4
+      with:
+        category: "/language:${{matrix.language}}"
\ No newline at end of file
diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml
new file mode 100644
index 0000000..0885752
--- /dev/null
+++ b/.github/workflows/gradle.yml
@@ -0,0 +1,67 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
+
+name: Java CI with Gradle
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+
+    # Configure Gradle for optimal use in GitHub Actions, including caching of downloaded dependencies.
+    # See: https://github.com/gradle/actions/blob/main/setup-gradle/README.md
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@af1da67850ed9a4cedd57bfd976089dd991e2582 # v4.0.0
+
+    - name: Build with Gradle Wrapper
+      run: ./gradlew build
+
+    # NOTE: The Gradle Wrapper is the default and recommended way to run Gradle (https://docs.gradle.org/current/userguide/gradle_wrapper.html).
+    # If your project does not have the Gradle Wrapper configured, you can use the following configuration to run Gradle with a specified version.
+    #
+    # - name: Setup Gradle
+    #   uses: gradle/actions/setup-gradle@af1da67850ed9a4cedd57bfd976089dd991e2582 # v4.0.0
+    #   with:
+    #     gradle-version: '8.9'
+    #
+    # - name: Build with Gradle 8.9
+    #   run: gradle build
+
+  dependency-submission:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+
+    # Generates and submits a dependency graph, enabling Dependabot Alerts for all project dependencies.
+    # See: https://github.com/gradle/actions/blob/main/dependency-submission/README.md
+    - name: Generate and submit dependency graph
+      uses: gradle/actions/dependency-submission@af1da67850ed9a4cedd57bfd976089dd991e2582 # v4.0.0
diff --git a/Auto Tech_House b/Auto Tech_House
new file mode 100644
index 0000000..b647e60
--- /dev/null
+++ b/Auto Tech_House	
@@ -0,0 +1 @@
+AI.DI
diff --git a/README.md b/README.md
index 98e1ad6..431aad1 100644
--- a/README.md
+++ b/README.md
@@ -1,31 +1,47 @@
-# Auto Techno
-Due to the limited amount of media apps which are available for Android Auto, I have decided to create one tailored to my music tastes.
-Auto Techno is an Android Auto music app for tuning in to DI.FM Premium radio channels.
+# Techouse
 
-Play Store link: https://play.google.com/store/apps/details?id=io.github.markspit93.autotechno
+## Usage
 
-The app was a nice opportunity to experiment with Google's media playing library, Exo Player 2.
-For more information:
- * https://developer.android.com/guide/topics/media/exoplayer.html
- * https://google.github.io/ExoPlayer/guide.html
+Java-Kotlin
+Java-Kotlin is a sample application created to explore the interoperability between Java and Kotlin within the Android ecosystem.
 
-## Usage
+The project demonstrates how both languages can coexist in the same environment, sharing classes, methods, and resources without losing compatibility or performance.
+
+Features
+Combined source code in Java and Kotlin
+Practical examples of interoperability between both languages
+Integration with modern Android libraries
+Modular and easily extensible architecture
+Ideal for developers migrating projects from Java to Kotlin
+
+Purpose
+The main goal of Java-Kotlin is to serve as an educational reference for understanding how Kotlin can be gradually integrated into existing Android projects written in Java.
+Through clear examples, it shows how both languages can communicate seamlessly, taking advantage of each one’s strengths.
+
+How It Improves Music Apps
+While Java-Kotlin itself doesn’t directly enhance music files, it can significantly improve how an app handles and plays them:
+
+Optimized performance: Kotlin’s concise and safe syntax reduces bugs that could affect playback or audio streaming.
+
+Better code maintenance: Interoperability allows developers to add new features (like equalizers, smart playlists, or streaming) without rewriting the entire codebase.
+
+Modern library support: Kotlin integrates smoothly with Android’s latest APIs, such as ExoPlayer, improving stability and audio buffer management.
+
+Lower resource usage: Kotlin’s compiler optimizations make reading, decoding, and playback operations more efficient.
+
+In short, Java-Kotlin doesn’t modify the music files themselves but enhances the development experience and efficiency of apps that manage or play them.
 
-**NOTE: DI.FM Premium Required**.
+Usage
+Clone or download the project.
+Open it in Android Studio with Kotlin support enabled.
 
-* Make sure Android *and Android Auto* is set to allow apps from unknown sources. Use some internet search tool for instructions.
-* Deploy to Android Device.
-    * If you're having problems, try to disable "Instant Run".
-    * Running the default "Activity" will prompt you to open Android Auto. It should not crash.
-* Start the mobile app and enter your Premium listener key.
-* Startup Android Auto and open the app.
+Build and run it on an Android device or emulator.
 
+Explore the Java and Kotlin modules to see how they interact.
 
-Screenshots
-======
+Integrated Kotlin and Java Code
 
-![Media Session](screenshot1.PNG)
+Running in Android Studio
 
-![Media Browser](screenshot2.PNG)
+**NOTE: DI.FM/APP Required**.
 
-![Media Browser](screenshot3.PNG)
diff --git a/name- -CodeQL Advanced-.pdf b/name- -CodeQL Advanced-.pdf
new file mode 100644
index 0000000..7f976fd
Binary files /dev/null and b/name- -CodeQL Advanced-.pdf differ