title: Failed to apply plugin: Found java version 11 Minimum required is 1.8. Versions 11.0.0 and newer are not supported yet
body: <p>I'm trying to build the <a href="https://github.com/MinecraftForge/MinecraftForge/tree/1.15.x/mdk" rel="nofollow noreferrer">Minecraft Forge MDK</a> using IntelliJ 2017.3.4 on MacOS 10.14.6. When I do <code>gradlew build</code> I get the following error:</p>
  
  <blockquote>
    <p>Failed to apply plugin [id 'net.minecraftforge.gradle']
    Found java version 11.0.4. Minimum required is 1.8.0_101. Versions 11.0.0 and newer are not supported yet.`</p>
  </blockquote>
  
  <p>However, I don't even have Java 11 installed. The project structure is set to 1.8:</p>
  
  <p><a href="https://i.stack.imgur.com/RwtVB.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/RwtVB.png" alt="project structure"></a></p>
  
  <p>I switched the IDE boot jdk to 1.8 as well:</p>
  
  <p><a href="https://i.stack.imgur.com/DyNN4.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/DyNN4.png" alt="switch boot jdk"></a></p>
  
  <p>And in Other Settings --> Default project structure I also have it set to Java 8:</p>
  
  <p><a href="https://i.stack.imgur.com/sNXls.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/sNXls.png" alt="Default project structure"></a></p>
  
  <p>Nevertheless, gradle thinks I'm trying to use Java 11. How on earth do I get it to recognize that I am using Java 8?</p>
  
  <p>Here is my build.gradle file: </p>
  
  <pre><code>buildscript {
      repositories {
          maven { url = 'https://files.minecraftforge.net/maven' }
          jcenter()
          mavenCentral()
      }
      dependencies {
          classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
      }
  }
  apply plugin: 'net.minecraftforge.gradle'
  // Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
  apply plugin: 'eclipse'
  apply plugin: 'maven-publish'
  
  version = '1.0'
  group = 'com.yourname.modid' // http://maven.apache.org/guides/mini/guide-naming-conventions.html
  archivesBaseName = 'modid'
  
  sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
  
  minecraft {
      // The mappings can be changed at any time, and must be in the following format.
      // snapshot_YYYYMMDD   Snapshot are built nightly.
      // stable_#            Stables are built at the discretion of the MCP team.
      // Use non-default mappings at your own risk. they may not always work.
      // Simply re-run your setup task after changing the mappings to update your workspace.
      mappings channel: 'snapshot', version: '20190719-1.14.3'
      // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
  
      // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
  
      // Default run configurations.
      // These can be tweaked, removed, or duplicated as needed.
      runs {
          client {
              workingDirectory project.file('run')
  
              // Recommended logging data for a userdev environment
              property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
  
              // Recommended logging level for the console
              property 'forge.logging.console.level', 'debug'
  
              mods {
                  examplemod {
                      source sourceSets.main
                  }
              }
          }
  
          server {
              workingDirectory project.file('run')
  
              // Recommended logging data for a userdev environment
              property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
  
              // Recommended logging level for the console
              property 'forge.logging.console.level', 'debug'
  
              mods {
                  examplemod {
                      source sourceSets.main
                  }
              }
          }
  
          data {
              workingDirectory project.file('run')
  
              // Recommended logging data for a userdev environment
              property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP'
  
              // Recommended logging level for the console
              property 'forge.logging.console.level', 'debug'
  
              args '--mod', 'examplemod', '--all', '--output', file('src/generated/resources/')
  
              mods {
                  examplemod {
                      source sourceSets.main
                  }
              }
          }
      }
  }
  
  dependencies {
      // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
      // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
      // The userdev artifact is a special name and will get all sorts of transformations applied to it.
      minecraft 'net.minecraftforge:forge:1.15.1-30.0.42'
  
      // You may put jars on which you depend on in ./libs or you may define them like so..
      // compile "some.group:artifact:version:classifier"
      // compile "some.group:artifact:version"
  
      // Real examples
      // compile 'com.mod-buildcraft:buildcraft:6.0.8:dev'  // adds buildcraft to the dev env
      // compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env
  
      // The 'provided' configuration is for optional dependencies that exist at compile-time but might not at runtime.
      // provided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
  
      // These dependencies get remapped to your current MCP mappings
      // deobf 'com.mod-buildcraft:buildcraft:6.0.8:dev'
  
      // For more info...
      // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
      // http://www.gradle.org/docs/current/userguide/dependency_management.html
  
  }
  
  // Example for how to get properties into the manifest for reading by the runtime..
  jar {
      manifest {
          attributes([
              "Specification-Title": "examplemod",
              "Specification-Vendor": "examplemodsareus",
              "Specification-Version": "1", // We are version 1 of ourselves
              "Implementation-Title": project.name,
              "Implementation-Version": "${version}",
              "Implementation-Vendor" :"examplemodsareus",
              "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
          ])
      }
  }
  
  // Example configuration to allow publishing using the maven-publish task
  // we define a custom artifact that is sourced from the reobfJar output task
  // and then declare that to be published
  // Note you'll need to add a repository here
  def reobfFile = file("$buildDir/reobfJar/output.jar")
  def reobfArtifact = artifacts.add('default', reobfFile) {
      type 'jar'
      builtBy 'reobfJar'
  }
  publishing {
      publications {
          mavenJava(MavenPublication) {
              artifact reobfArtifact
          }
      }
      repositories {
          maven {
              url "file:///${project.projectDir}/mcmodsrepo"
          }
      }
  }
  </code></pre>
  
  <p>And here is my gradlew file:</p>
  
  <pre><code>#!/usr/bin/env sh
  
  ##############################################################################
  ##
  ##  Gradle start up script for UN*X
  ##
  ##############################################################################
  
  # Attempt to set APP_HOME
  # Resolve links: $0 may be a link
  PRG="$0"
  # Need this for relative symlinks.
  while [ -h "$PRG" ] ; do
      ls=`ls -ld "$PRG"`
      link=`expr "$ls" : '.*-&gt; \(.*\)$'`
      if expr "$link" : '/.*' &gt; /dev/null; then
          PRG="$link"
      else
          PRG=`dirname "$PRG"`"/$link"
      fi
  done
  SAVED="`pwd`"
  cd "`dirname \"$PRG\"`/" &gt;/dev/null
  APP_HOME="`pwd -P`"
  cd "$SAVED" &gt;/dev/null
  
  APP_NAME="Gradle"
  APP_BASE_NAME=`basename "$0"`
  
  # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
  DEFAULT_JVM_OPTS=""
  
  # Use the maximum available, or set MAX_FD != -1 to use that value.
  MAX_FD="maximum"
  
  warn () {
      echo "$*"
  }
  
  die () {
      echo
      echo "$*"
      echo
      exit 1
  }
  
  # OS specific support (must be 'true' or 'false').
  cygwin=false
  msys=false
  darwin=false
  nonstop=false
  case "`uname`" in
    CYGWIN* )
      cygwin=true
      ;;
    Darwin* )
      darwin=true
      ;;
    MINGW* )
      msys=true
      ;;
    NONSTOP* )
      nonstop=true
      ;;
  esac
  
  CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
  
  # Determine the Java command to use to start the JVM.
  if [ -n "$JAVA_HOME" ] ; then
      if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
          # IBM's JDK on AIX uses strange locations for the executables
          JAVACMD="$JAVA_HOME/jre/sh/java"
      else
          JAVACMD="$JAVA_HOME/bin/java"
      fi
      if [ ! -x "$JAVACMD" ] ; then
          die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
  
  Please set the JAVA_HOME variable in your environment to match the
  location of your Java installation."
      fi
  else
      JAVACMD="java"
      which java &gt;/dev/null 2&gt;&amp;1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
  
  Please set the JAVA_HOME variable in your environment to match the
  location of your Java installation."
  fi
  
  # Increase the maximum file descriptors if we can.
  if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
      MAX_FD_LIMIT=`ulimit -H -n`
      if [ $? -eq 0 ] ; then
          if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
              MAX_FD="$MAX_FD_LIMIT"
          fi
          ulimit -n $MAX_FD
          if [ $? -ne 0 ] ; then
              warn "Could not set maximum file descriptor limit: $MAX_FD"
          fi
      else
          warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
      fi
  fi
  
  # For Darwin, add options to specify how the application appears in the dock
  if $darwin; then
      GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
  fi
  
  # For Cygwin, switch paths to Windows format before running java
  if $cygwin ; then
      APP_HOME=`cygpath --path --mixed "$APP_HOME"`
      CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
      JAVACMD=`cygpath --unix "$JAVACMD"`
  
      # We build the pattern for arguments to be converted via cygpath
      ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2&gt;/dev/null`
      SEP=""
      for dir in $ROOTDIRSRAW ; do
          ROOTDIRS="$ROOTDIRS$SEP$dir"
          SEP="|"
      done
      OURCYGPATTERN="(^($ROOTDIRS))"
      # Add a user-defined pattern to the cygpath arguments
      if [ "$GRADLE_CYGPATTERN" != "" ] ; then
          OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
      fi
      # Now convert the arguments - kludge to limit ourselves to /bin/sh
      i=0
      for arg in "$@" ; do
          CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
          CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
  
          if [ $CHECK -ne 0 ] &amp;&amp; [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
              eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
          else
              eval `echo args$i`="\"$arg\""
          fi
          i=$((i+1))
      done
      case $i in
          (0) set -- ;;
          (1) set -- "$args0" ;;
          (2) set -- "$args0" "$args1" ;;
          (3) set -- "$args0" "$args1" "$args2" ;;
          (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
          (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
          (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
          (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
          (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
          (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
      esac
  fi
  
  # Escape application args
  save () {
      for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
      echo " "
  }
  APP_ARGS=$(save "$@")
  
  # Collect all arguments for the java command, following the shell quoting and substitution rules
  eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
  
  # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
  if [ "$(uname)" = "Darwin" ] &amp;&amp; [ "$HOME" = "$PWD" ]; then
    cd "$(dirname "$0")"
  fi
  
  exec "$JAVACMD" "$@"
  </code></pre>