diff --git a/src/main/bash/sdkman-broadcast.sh b/src/main/bash/sdkman-broadcast.sh
index 8c69337a..72615f1b 100644
--- a/src/main/bash/sdkman-broadcast.sh
+++ b/src/main/bash/sdkman-broadcast.sh
@@ -24,32 +24,32 @@ function __sdkman_broadcast {
 	fi
 }
 
-function gvm_update_broadcast_or_force_offline {
-    BROADCAST_LIVE_ID=$(gvm_infer_broadcast_id)
+function sdkman_update_broadcast_or_force_offline {
+    BROADCAST_LIVE_ID=$(sdkman_infer_broadcast_id)
 
-    gvm_force_offline_on_proxy "$BROADCAST_LIVE_ID"
-    if [[ "$GVM_FORCE_OFFLINE" == 'true' ]]; then BROADCAST_LIVE_ID=""; fi
+    sdkman_force_offline_on_proxy "$BROADCAST_LIVE_ID"
+    if [[ "$SDKMAN_FORCE_OFFLINE" == 'true' ]]; then BROADCAST_LIVE_ID=""; fi
 
-    gvm_display_online_availability
-    gvm_determine_offline "$BROADCAST_LIVE_ID"
+    sdkman_display_online_availability
+    sdkman_determine_offline "$BROADCAST_LIVE_ID"
 
 	sdkman_update_broadcast "$COMMAND" "$BROADCAST_LIVE_ID"
 }
 
-function gvm_infer_broadcast_id {
-	if [[ "$GVM_FORCE_OFFLINE" == "true" || ( "$COMMAND" == "offline" && "$QUALIFIER" == "enable" ) ]]; then
+function sdkman_infer_broadcast_id {
+	if [[ "$SDKMAN_FORCE_OFFLINE" == "true" || ( "$COMMAND" == "offline" && "$QUALIFIER" == "enable" ) ]]; then
 		echo ""
 	else
-		echo $(curl -s "${GVM_BROADCAST_SERVICE}/broadcast/latest/id")
+		echo $(curl -s "${SDKMAN_BROADCAST_SERVICE}/broadcast/latest/id")
 	fi
 }
 
-function gvm_display_online_availability {
-	if [[ -z "$BROADCAST_LIVE_ID" && "$GVM_ONLINE" == "true" && "$COMMAND" != "offline" ]]; then
+function sdkman_display_online_availability {
+	if [[ -z "$BROADCAST_LIVE_ID" && "$SDKMAN_ONLINE" == "true" && "$COMMAND" != "offline" ]]; then
 		echo "$OFFLINE_BROADCAST"
 	fi
 
-	if [[ -n "$BROADCAST_LIVE_ID" && "$GVM_ONLINE" == "false" ]]; then
+	if [[ -n "$BROADCAST_LIVE_ID" && "$SDKMAN_ONLINE" == "false" ]]; then
 		echo "$ONLINE_BROADCAST"
 	fi
 }
@@ -58,8 +58,8 @@ function sdkman_update_broadcast {
 	local command="$1"
 	local broadcast_live_id="$2"
 
-	local broadcast_id_file="${GVM_DIR}/var/broadcast_id"
-	local broadcast_text_file="${GVM_DIR}/var/broadcast"
+	local broadcast_id_file="${SDKMAN_DIR}/var/broadcast_id"
+	local broadcast_text_file="${SDKMAN_DIR}/var/broadcast"
 
 	local broadcast_old_id=""
 
@@ -71,12 +71,12 @@ function sdkman_update_broadcast {
 		BROADCAST_OLD_TEXT=$(cat "$broadcast_text_file");
 	fi
 
-	if [[ "${GVM_AVAILABLE}" == "true" && "$broadcast_live_id" != "${broadcast_old_id}" && "$command" != "selfupdate" && "$command" != "flush" ]]; then
-		mkdir -p "${GVM_DIR}/var"
+	if [[ "${SDKMAN_AVAILABLE}" == "true" && "$broadcast_live_id" != "${broadcast_old_id}" && "$command" != "selfupdate" && "$command" != "flush" ]]; then
+		mkdir -p "${SDKMAN_DIR}/var"
 
 		echo "${broadcast_live_id}" > "$broadcast_id_file"
 
-		BROADCAST_LIVE_TEXT=$(curl -s "${GVM_BROADCAST_SERVICE}/broadcast/latest")
+		BROADCAST_LIVE_TEXT=$(curl -s "${SDKMAN_BROADCAST_SERVICE}/broadcast/latest")
 		echo "${BROADCAST_LIVE_TEXT}" > "${broadcast_text_file}"
 		echo "${BROADCAST_LIVE_TEXT}"
 	fi
diff --git a/src/main/bash/sdkman-common.sh b/src/main/bash/sdkman-common.sh
index 4bd8b338..fa718577 100644
--- a/src/main/bash/sdkman-common.sh
+++ b/src/main/bash/sdkman-common.sh
@@ -38,34 +38,34 @@ function __sdkman_check_version_present {
 }
 
 function __sdkman_determine_version {
-	if [[ "${GVM_AVAILABLE}" == "false" && -n "$1" && -d "${GVM_DIR}/${CANDIDATE}/$1" ]]; then
+	if [[ "${SDKMAN_AVAILABLE}" == "false" && -n "$1" && -d "${SDKMAN_DIR}/${CANDIDATE}/$1" ]]; then
 		VERSION="$1"
 
-	elif [[ "${GVM_AVAILABLE}" == "false" && -z "$1" && -L "${GVM_DIR}/${CANDIDATE}/current" ]]; then
+	elif [[ "${SDKMAN_AVAILABLE}" == "false" && -z "$1" && -L "${SDKMAN_DIR}/${CANDIDATE}/current" ]]; then
 
-		VERSION=$(readlink "${GVM_DIR}/${CANDIDATE}/current" | sed "s!${GVM_DIR}/${CANDIDATE}/!!g")
+		VERSION=$(readlink "${SDKMAN_DIR}/${CANDIDATE}/current" | sed "s!${SDKMAN_DIR}/${CANDIDATE}/!!g")
 
-	elif [[ "${GVM_AVAILABLE}" == "false" && -n "$1" ]]; then
+	elif [[ "${SDKMAN_AVAILABLE}" == "false" && -n "$1" ]]; then
 		echo "Stop! ${CANDIDATE} ${1} is not available in offline mode."
 		return 1
 
-	elif [[ "${GVM_AVAILABLE}" == "false" && -z "$1" ]]; then
+	elif [[ "${SDKMAN_AVAILABLE}" == "false" && -z "$1" ]]; then
         echo "${OFFLINE_MESSAGE}"
         return 1
 
-	elif [[ "${GVM_AVAILABLE}" == "true" && -z "$1" ]]; then
+	elif [[ "${SDKMAN_AVAILABLE}" == "true" && -z "$1" ]]; then
 		VERSION_VALID='valid'
-		VERSION=$(curl -s "${GVM_SERVICE}/candidates/${CANDIDATE}/default")
+		VERSION=$(curl -s "${SDKMAN_SERVICE}/candidates/${CANDIDATE}/default")
 
 	else
-		VERSION_VALID=$(curl -s "${GVM_SERVICE}/candidates/${CANDIDATE}/$1")
+		VERSION_VALID=$(curl -s "${SDKMAN_SERVICE}/candidates/${CANDIDATE}/$1")
 		if [[ "${VERSION_VALID}" == 'valid' || ( "${VERSION_VALID}" == 'invalid' && -n "$2" ) ]]; then
 			VERSION="$1"
 
-		elif [[ "${VERSION_VALID}" == 'invalid' && -h "${GVM_DIR}/${CANDIDATE}/$1" ]]; then
+		elif [[ "${VERSION_VALID}" == 'invalid' && -h "${SDKMAN_DIR}/${CANDIDATE}/$1" ]]; then
 			VERSION="$1"
 
-		elif [[ "${VERSION_VALID}" == 'invalid' && -d "${GVM_DIR}/${CANDIDATE}/$1" ]]; then
+		elif [[ "${VERSION_VALID}" == 'invalid' && -d "${SDKMAN_DIR}/${CANDIDATE}/$1" ]]; then
 			VERSION="$1"
 
 		else
@@ -78,18 +78,18 @@ function __sdkman_determine_version {
 
 function __sdkman_default_environment_variables {
 
-	if [ ! "$GVM_FORCE_OFFLINE" ]; then
-		GVM_FORCE_OFFLINE="false"
+	if [ ! "$SDKMAN_FORCE_OFFLINE" ]; then
+		SDKMAN_FORCE_OFFLINE="false"
 	fi
 
-	if [ ! "$GVM_ONLINE" ]; then
-		GVM_ONLINE="true"
+	if [ ! "$SDKMAN_ONLINE" ]; then
+		SDKMAN_ONLINE="true"
 	fi
 
-	if [[ "${GVM_ONLINE}" == "false" || "${GVM_FORCE_OFFLINE}" == "true" ]]; then
-		GVM_AVAILABLE="false"
+	if [[ "${SDKMAN_ONLINE}" == "false" || "${SDKMAN_FORCE_OFFLINE}" == "true" ]]; then
+		SDKMAN_AVAILABLE="false"
 	else
-	  	GVM_AVAILABLE="true"
+	  	SDKMAN_AVAILABLE="true"
 	fi
 }
 
@@ -98,8 +98,8 @@ function __sdkman_link_candidate_version {
 	VERSION="$2"
 
 	# Change the 'current' symlink for the candidate, hence affecting all shells.
-	if [ -L "${GVM_DIR}/${CANDIDATE}/current" ]; then
-		unlink "${GVM_DIR}/${CANDIDATE}/current"
+	if [ -L "${SDKMAN_DIR}/${CANDIDATE}/current" ]; then
+		unlink "${SDKMAN_DIR}/${CANDIDATE}/current"
 	fi
-	ln -s "${GVM_DIR}/${CANDIDATE}/${VERSION}" "${GVM_DIR}/${CANDIDATE}/current"
+	ln -s "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" "${SDKMAN_DIR}/${CANDIDATE}/current"
 }
\ No newline at end of file
diff --git a/src/main/bash/sdkman-current.sh b/src/main/bash/sdkman-current.sh
index 1e52c693..8c426178 100644
--- a/src/main/bash/sdkman-current.sh
+++ b/src/main/bash/sdkman-current.sh
@@ -19,11 +19,11 @@
 function __sdkman_determine_current_version {
 	CANDIDATE="$1"
 	if [[ "${solaris}" == true ]]; then
-		CURRENT=$(echo $PATH | gsed -r "s|${GVM_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | gsed -r "s|^.*!!(.+)!!.*$|\1|g")
+		CURRENT=$(echo $PATH | gsed -r "s|${SDKMAN_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | gsed -r "s|^.*!!(.+)!!.*$|\1|g")
 	elif [[ "${darwin}" == true ]]; then
-		CURRENT=$(echo $PATH | sed -E "s|${GVM_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | sed -E "s|^.*!!(.+)!!.*$|\1|g")
+		CURRENT=$(echo $PATH | sed -E "s|${SDKMAN_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | sed -E "s|^.*!!(.+)!!.*$|\1|g")
 	else
-		CURRENT=$(echo $PATH | sed -r "s|${GVM_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | sed -r "s|^.*!!(.+)!!.*$|\1|g")
+		CURRENT=$(echo $PATH | sed -r "s|${SDKMAN_DIR}/${CANDIDATE}/([^/]+)/bin|!!\1!!|1" | sed -r "s|^.*!!(.+)!!.*$|\1|g")
 	fi
 
 	if [[ "${CURRENT}" == "current" ]]; then
@@ -31,7 +31,7 @@ function __sdkman_determine_current_version {
 	fi
 
 	if [[ -z ${CURRENT} ]]; then
-		CURRENT=$(readlink "${GVM_DIR}/${CANDIDATE}/current" | sed "s!${GVM_DIR}/${CANDIDATE}/!!g")
+		CURRENT=$(readlink "${SDKMAN_DIR}/${CANDIDATE}/current" | sed "s!${SDKMAN_DIR}/${CANDIDATE}/!!g")
 	fi
 }
 
@@ -46,15 +46,15 @@ function __sdkman_current {
 		fi
 	else
 		INSTALLED_COUNT=0
-		for (( i=0; i <= ${#GVM_CANDIDATES}; i++ )); do
+		for (( i=0; i <= ${#SDKMAN_CANDIDATES}; i++ )); do
 			# Eliminate empty entries due to incompatibility
-			if [[ -n ${GVM_CANDIDATES[${i}]} ]]; then
-				__sdkman_determine_current_version "${GVM_CANDIDATES[${i}]}"
+			if [[ -n ${SDKMAN_CANDIDATES[${i}]} ]]; then
+				__sdkman_determine_current_version "${SDKMAN_CANDIDATES[${i}]}"
 				if [ -n "${CURRENT}" ]; then
 					if [ ${INSTALLED_COUNT} -eq 0 ]; then
 						echo 'Using:'
 					fi
-					echo "${GVM_CANDIDATES[${i}]}: ${CURRENT}"
+					echo "${SDKMAN_CANDIDATES[${i}]}: ${CURRENT}"
 					(( INSTALLED_COUNT += 1 ))
 				fi
 			fi
diff --git a/src/main/bash/sdkman-default.sh b/src/main/bash/sdkman-default.sh
index 5308d731..96349ba2 100644
--- a/src/main/bash/sdkman-default.sh
+++ b/src/main/bash/sdkman-default.sh
@@ -21,7 +21,7 @@ function __sdkman_default {
 	__sdkman_check_candidate_present "${CANDIDATE}" || return 1
 	__sdkman_determine_version "$2" || return 1
 
-	if [ ! -d "${GVM_DIR}/${CANDIDATE}/${VERSION}" ]; then
+	if [ ! -d "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" ]; then
 		echo ""
 		echo "Stop! ${CANDIDATE} ${VERSION} is not installed."
 		return 1
diff --git a/src/main/bash/sdkman-flush.sh b/src/main/bash/sdkman-flush.sh
index 509e412d..50a87feb 100644
--- a/src/main/bash/sdkman-flush.sh
+++ b/src/main/bash/sdkman-flush.sh
@@ -17,42 +17,42 @@
 #
 
 function __sdkman_cleanup_folder {
-	GVM_CLEANUP_DIR="${GVM_DIR}/${1}"
-	GVM_CLEANUP_DU=$(du -sh "$GVM_CLEANUP_DIR")
-	GVM_CLEANUP_COUNT=$(ls -1 "$GVM_CLEANUP_DIR" | wc -l)
+	SDKMAN_CLEANUP_DIR="${SDKMAN_DIR}/${1}"
+	SDKMAN_CLEANUP_DU=$(du -sh "$SDKMAN_CLEANUP_DIR")
+	SDKMAN_CLEANUP_COUNT=$(ls -1 "$SDKMAN_CLEANUP_DIR" | wc -l)
 
-	rm -rf "${GVM_DIR}/${1}"
-	mkdir "${GVM_DIR}/${1}"
+	rm -rf "${SDKMAN_DIR}/${1}"
+	mkdir "${SDKMAN_DIR}/${1}"
 
-	echo "${GVM_CLEANUP_COUNT} archive(s) flushed, freeing ${GVM_CLEANUP_DU}."
+	echo "${SDKMAN_CLEANUP_COUNT} archive(s) flushed, freeing ${SDKMAN_CLEANUP_DU}."
 
-	unset GVM_CLEANUP_DIR
-	unset GVM_CLEANUP_DU
-	unset GVM_CLEANUP_COUNT
+	unset SDKMAN_CLEANUP_DIR
+	unset SDKMAN_CLEANUP_DU
+	unset SDKMAN_CLEANUP_COUNT
 }
 
 function __sdkman_flush {
 	QUALIFIER="$1"
 	case "$QUALIFIER" in
 		candidates)
-			if [[ -f "${GVM_DIR}/var/candidates" ]]; then
-		        rm "${GVM_DIR}/var/candidates"
+			if [[ -f "${SDKMAN_DIR}/var/candidates" ]]; then
+		        rm "${SDKMAN_DIR}/var/candidates"
 		        echo "Candidates have been flushed."
 		    else
 		        echo "No candidate list found so not flushed."
 		    fi
 		    ;;
 		broadcast)
-			if [[ -f "${GVM_DIR}/var/broadcast" ]]; then
-		        rm "${GVM_DIR}/var/broadcast"
+			if [[ -f "${SDKMAN_DIR}/var/broadcast" ]]; then
+		        rm "${SDKMAN_DIR}/var/broadcast"
 		        echo "Broadcast has been flushed."
 		    else
 		        echo "No prior broadcast found so not flushed."
 		    fi
 		    ;;
 		version)
-			if [[ -f "${GVM_DIR}/var/version" ]]; then
-		        rm "${GVM_DIR}/var/version"
+			if [[ -f "${SDKMAN_DIR}/var/version" ]]; then
+		        rm "${SDKMAN_DIR}/var/version"
 		        echo "Version Token has been flushed."
 		    else
 		        echo "No prior Remote Version found so not flushed."
diff --git a/src/main/bash/sdkman-help.sh b/src/main/bash/sdkman-help.sh
index 1d797a3b..4be7e73a 100644
--- a/src/main/bash/sdkman-help.sh
+++ b/src/main/bash/sdkman-help.sh
@@ -18,8 +18,8 @@
 
 function __sdkman_help {
 	echo ""
-	echo "Usage: gvm <command> <candidate> [version]"
-	echo "       gvm offline <enable|disable>"
+	echo "Usage: sdk <command> <candidate> [version]"
+	echo "       sdk offline <enable|disable>"
 	echo ""
 	echo "   commands:"
 	echo "       install   or i    <candidate> [version]"
@@ -37,8 +37,8 @@ function __sdkman_help {
 	echo "       flush             <candidates|broadcast|archives|temp>"
 	echo ""
 	echo -n "   candidate  :  "
-	echo "$GVM_CANDIDATES_CSV" | sed 's/,/, /g'
+	echo "$SDKMAN_CANDIDATES_CSV" | sed 's/,/, /g'
 	echo "   version    :  where optional, defaults to latest stable if not provided"
 	echo ""
-	echo "eg: gvm install groovy"
+	echo "eg: sdk install groovy"
 }
diff --git a/src/main/bash/sdkman-init.sh b/src/main/bash/sdkman-init.sh
index d46b4fae..e1903f82 100644
--- a/src/main/bash/sdkman-init.sh
+++ b/src/main/bash/sdkman-init.sh
@@ -16,25 +16,49 @@
 #   limitations under the License.
 #
 
-export GVM_VERSION="@GVM_VERSION@"
-export GVM_PLATFORM=$(uname)
+export SDKMAN_VERSION="@SDKMAN_VERSION@"
+export SDKMAN_PLATFORM=$(uname)
 
-if [ -z "${GVM_SERVICE}" ]; then
-    export GVM_SERVICE="@GVM_SERVICE@"
+if [ -z "${SDKMAN_SERVICE}" ]; then
+    export SDKMAN_SERVICE="@SDKMAN_SERVICE@"
 fi
 
-if [ -z "${GVM_BROADCAST_SERVICE}" ]; then
-    export GVM_BROADCAST_SERVICE="@GVM_BROADCAST_SERVICE@"
+if [ -z "${SDKMAN_BROADCAST_SERVICE}" ]; then
+    export SDKMAN_BROADCAST_SERVICE="@SDKMAN_BROADCAST_SERVICE@"
 fi
 
-if [ -z "${GVM_BROKER_SERVICE}" ]; then
-    export GVM_BROKER_SERVICE="@GVM_BROKER_SERVICE@"
+if [ -z "${SDKMAN_BROKER_SERVICE}" ]; then
+    export SDKMAN_BROKER_SERVICE="@SDKMAN_BROKER_SERVICE@"
 fi
 
-if [ -z "${GVM_DIR}" ]; then
-	export GVM_DIR="$HOME/.gvm"
+if [ -z "${SDKMAN_DIR}" ]; then
+	export SDKMAN_DIR="$HOME/.sdkman"
 fi
 
+function sdkman_source_modules {
+	# Source sdkman module scripts.
+    for f in $(find "${SDKMAN_DIR}/src" -type f -name 'sdkman-*' -exec basename {} \;); do
+        source "${SDKMAN_DIR}/src/${f}"
+    done
+
+	# Source extension files prefixed with 'sdkman-' and found in the ext/ folder
+	# Use this if extensions are written with the functional approach and want
+	# to use functions in the main sdkman script.
+	for f in $(find "${SDKMAN_DIR}/ext" -type f -name 'sdkman-*' -exec basename {} \;); do
+		source "${SDKMAN_DIR}/ext/${f}"
+	done
+	unset f
+}
+
+function sdkman_set_candidates {
+    # Set the candidate array
+    OLD_IFS="$IFS"
+    IFS=","
+    SDKMAN_CANDIDATES=(${SDKMAN_CANDIDATES_CSV})
+    IFS="$OLD_IFS"
+}
+
+
 # force zsh to behave well
 if [[ -n "$ZSH_VERSION" ]]; then
 	setopt shwordsplit
@@ -88,11 +112,11 @@ EOF
 OFFLINE_MESSAGE="This command is not available in offline mode."
 
 # fabricate list of candidates
-if [[ -f "${GVM_DIR}/var/candidates" ]]; then
-	GVM_CANDIDATES_CSV=$(cat "${GVM_DIR}/var/candidates")
+if [[ -f "${SDKMAN_DIR}/var/candidates" ]]; then
+	SDKMAN_CANDIDATES_CSV=$(cat "${SDKMAN_DIR}/var/candidates")
 else
-	GVM_CANDIDATES_CSV=$(curl -s "${GVM_SERVICE}/candidates")
-	echo "$GVM_CANDIDATES_CSV" > "${GVM_DIR}/var/candidates"
+	SDKMAN_CANDIDATES_CSV=$(curl -s "${SDKMAN_SERVICE}/candidates")
+	echo "$SDKMAN_CANDIDATES_CSV" > "${SDKMAN_DIR}/var/candidates"
 fi
 
 
@@ -100,19 +124,19 @@ fi
 # Set the candidate array
 OLD_IFS="$IFS"
 IFS=","
-GVM_CANDIDATES=(${GVM_CANDIDATES_CSV})
+SDKMAN_CANDIDATES=(${SDKMAN_CANDIDATES_CSV})
 IFS="$OLD_IFS"
 
-# Source gvm module scripts.
-for f in $(find "${GVM_DIR}/src" -type f -name 'gvm-*' -exec basename {} \;); do
-    source "${GVM_DIR}/src/${f}"
+# Source sdkman module scripts.
+for f in $(find "${SDKMAN_DIR}/src" -type f -name 'sdkman-*' -exec basename {} \;); do
+    source "${SDKMAN_DIR}/src/${f}"
 done
 
-# Source extension files prefixed with 'gvm-' and found in the ext/ folder
+# Source extension files prefixed with 'sdkman-' and found in the ext/ folder
 # Use this if extensions are written with the functional approach and want
-# to use functions in the main gvm script.
-for f in $(find "${GVM_DIR}/ext" -type f -name 'gvm-*' -exec basename {} \;); do
-    source "${GVM_DIR}/ext/${f}"
+# to use functions in the main sdkman script.
+for f in $(find "${SDKMAN_DIR}/ext" -type f -name 'sdkman-*' -exec basename {} \;); do
+    source "${SDKMAN_DIR}/ext/${f}"
 done
 unset f
 
@@ -124,58 +148,58 @@ if [ -z "${JAVA_HOME}" ] ; then
         [ -z "${JAVA_HOME}" -a -d "/System/Library/Frameworks/JavaVM.framework/Home" ] && export JAVA_HOME="/System/Library/Frameworks/JavaVM.framework/Home"
     else
         javaExecutable="$(which javac 2> /dev/null)"
-        [[ -z "${javaExecutable}" ]] && echo "GVM: JAVA_HOME not set and cannot find javac to deduce location, please set JAVA_HOME." && return
+        [[ -z "${javaExecutable}" ]] && echo "SDKMAN: JAVA_HOME not set and cannot find javac to deduce location, please set JAVA_HOME." && return
 
         readLink="$(which readlink 2> /dev/null)"
-        [[ -z "${readLink}" ]] && echo "GVM: JAVA_HOME not set and readlink not available, please set JAVA_HOME." && return
+        [[ -z "${readLink}" ]] && echo "SDKMAN: JAVA_HOME not set and readlink not available, please set JAVA_HOME." && return
 
         javaExecutable="$(readlink -f "${javaExecutable}")"
         javaHome="$(dirname "${javaExecutable}")"
         javaHome=$(expr "${javaHome}" : '\(.*\)/bin')
         JAVA_HOME="${javaHome}"
-        [[ -z "${JAVA_HOME}" ]] && echo "GVM: could not find java, please set JAVA_HOME" && return
+        [[ -z "${JAVA_HOME}" ]] && echo "SDKMAN: could not find java, please set JAVA_HOME" && return
         export JAVA_HOME
     fi
 fi
 
-# Load the gvm config if it exists.
-if [ -f "${GVM_DIR}/etc/config" ]; then
-	source "${GVM_DIR}/etc/config"
+# Load the sdkman config if it exists.
+if [ -f "${SDKMAN_DIR}/etc/config" ]; then
+	source "${SDKMAN_DIR}/etc/config"
 fi
 
 # Create upgrade delay token if it doesn't exist
-if [[ ! -f "${GVM_DIR}/var/delay_upgrade" ]]; then
-	touch "${GVM_DIR}/var/delay_upgrade"
+if [[ ! -f "${SDKMAN_DIR}/var/delay_upgrade" ]]; then
+	touch "${SDKMAN_DIR}/var/delay_upgrade"
 fi
 
 # determine if up to date
-GVM_VERSION_TOKEN="${GVM_DIR}/var/version"
-if [[ -f "$GVM_VERSION_TOKEN" && -z "$(find "$GVM_VERSION_TOKEN" -mmin +$((60*24)))" ]]; then
-    GVM_REMOTE_VERSION=$(cat "$GVM_VERSION_TOKEN")
+SDKMAN_VERSION_TOKEN="${SDKMAN_DIR}/var/version"
+if [[ -f "$SDKMAN_VERSION_TOKEN" && -z "$(find "$SDKMAN_VERSION_TOKEN" -mmin +$((60*24)))" ]]; then
+    SDKMAN_REMOTE_VERSION=$(cat "$SDKMAN_VERSION_TOKEN")
 
 else
-    GVM_REMOTE_VERSION=$(curl -s "${GVM_SERVICE}/app/version" --connect-timeout 1 --max-time 1)
-    gvm_force_offline_on_proxy "$GVM_REMOTE_VERSION"
-    if [[ -z "$GVM_REMOTE_VERSION" || "$GVM_FORCE_OFFLINE" == 'true' ]]; then
-        GVM_REMOTE_VERSION="$GVM_VERSION"
+    SDKMAN_REMOTE_VERSION=$(curl -s "${SDKMAN_SERVICE}/app/version" --connect-timeout 1 --max-time 1)
+    sdkman_force_offline_on_proxy "$SDKMAN_REMOTE_VERSION"
+    if [[ -z "$SDKMAN_REMOTE_VERSION" || "$SDKMAN_FORCE_OFFLINE" == 'true' ]]; then
+        SDKMAN_REMOTE_VERSION="$SDKMAN_VERSION"
     else
-        echo ${GVM_REMOTE_VERSION} > "$GVM_VERSION_TOKEN"
+        echo ${SDKMAN_REMOTE_VERSION} > "$SDKMAN_VERSION_TOKEN"
     fi
 fi
 
 # initialise once only
-if [[ "${GVM_INIT}" != "true" ]]; then
+if [[ "${SDKMAN_INIT}" != "true" ]]; then
     # Build _HOME environment variables and prefix them all to PATH
 
     # The candidates are assigned to an array for zsh compliance, a list of words is not iterable
     # Arrays are the only way, but unfortunately zsh arrays are not backward compatible with bash
     # In bash arrays are zero index based, in zsh they are 1 based(!)
-    for (( i=0; i <= ${#GVM_CANDIDATES}; i++ )); do
+    for (( i=0; i <= ${#SDKMAN_CANDIDATES}; i++ )); do
         # Eliminate empty entries due to incompatibility
-        if [[ -n ${GVM_CANDIDATES[${i}]} ]]; then
-            CANDIDATE_NAME="${GVM_CANDIDATES[${i}]}"
+        if [[ -n ${SDKMAN_CANDIDATES[${i}]} ]]; then
+            CANDIDATE_NAME="${SDKMAN_CANDIDATES[${i}]}"
             CANDIDATE_HOME_VAR="$(echo ${CANDIDATE_NAME} | tr '[:lower:]' '[:upper:]')_HOME"
-            CANDIDATE_DIR="${GVM_DIR}/${CANDIDATE_NAME}/current"
+            CANDIDATE_DIR="${SDKMAN_DIR}/${CANDIDATE_NAME}/current"
             export $(echo ${CANDIDATE_HOME_VAR})="$CANDIDATE_DIR"
             PATH="${CANDIDATE_DIR}/bin:${PATH}"
             unset CANDIDATE_HOME_VAR
@@ -186,5 +210,5 @@ if [[ "${GVM_INIT}" != "true" ]]; then
     unset i
     export PATH
 
-    export GVM_INIT="true"
+    export SDKMAN_INIT="true"
 fi
\ No newline at end of file
diff --git a/src/main/bash/sdkman-install.sh b/src/main/bash/sdkman-install.sh
index d07d8ba4..8276f8eb 100644
--- a/src/main/bash/sdkman-install.sh
+++ b/src/main/bash/sdkman-install.sh
@@ -19,13 +19,13 @@
 function __sdkman_download {
 	CANDIDATE="$1"
 	VERSION="$2"
-	mkdir -p "${GVM_DIR}/archives"
-	if [ ! -f "${GVM_DIR}/archives/${CANDIDATE}-${VERSION}.zip" ]; then
+	mkdir -p "${SDKMAN_DIR}/archives"
+	if [ ! -f "${SDKMAN_DIR}/archives/${CANDIDATE}-${VERSION}.zip" ]; then
 		echo ""
 		echo "Downloading: ${CANDIDATE} ${VERSION}"
 		echo ""
-		DOWNLOAD_URL="${GVM_SERVICE}/download/${CANDIDATE}/${VERSION}?platform=${GVM_PLATFORM}"
-		ZIP_ARCHIVE="${GVM_DIR}/archives/${CANDIDATE}-${VERSION}.zip"
+		DOWNLOAD_URL="${SDKMAN_SERVICE}/download/${CANDIDATE}/${VERSION}?platform=${SDKMAN_PLATFORM}"
+		ZIP_ARCHIVE="${SDKMAN_DIR}/archives/${CANDIDATE}-${VERSION}.zip"
 		if [[ "$sdkman_insecure_ssl" == "true" ]]; then
 			curl -k -L "${DOWNLOAD_URL}" > "${ZIP_ARCHIVE}"
 		else
@@ -34,7 +34,7 @@ function __sdkman_download {
 	else
 		echo ""
 		echo "Found a previously downloaded ${CANDIDATE} ${VERSION} archive. Not downloading it again..."
-		__sdkman_validate_zip "${GVM_DIR}/archives/${CANDIDATE}-${VERSION}.zip" || return 1
+		__sdkman_validate_zip "${SDKMAN_DIR}/archives/${CANDIDATE}-${VERSION}.zip" || return 1
 	fi
 	echo ""
 }
@@ -56,7 +56,7 @@ function __sdkman_install {
 	__sdkman_check_candidate_present "${CANDIDATE}" || return 1
 	__sdkman_determine_version "$2" "$3" || return 1
 
-	if [[ -d "${GVM_DIR}/${CANDIDATE}/${VERSION}" || -h "${GVM_DIR}/${CANDIDATE}/${VERSION}" ]]; then
+	if [[ -d "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" || -h "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" ]]; then
 		echo ""
 		echo "Stop! ${CANDIDATE} ${VERSION} is already installed."
 		return 0
@@ -65,7 +65,7 @@ function __sdkman_install {
 	if [[ ${VERSION_VALID} == 'valid' ]]; then
 		__sdkman_install_candidate_version "${CANDIDATE}" "${VERSION}" || return 1
 
-		if [[ "${gvm_auto_answer}" != 'true' ]]; then
+		if [[ "${sdkman_auto_answer}" != 'true' ]]; then
 			echo -n "Do you want ${CANDIDATE} ${VERSION} to be set as default? (Y/n): "
 			read USE
 		fi
@@ -90,10 +90,10 @@ function __sdkman_install_local_version {
 	CANDIDATE="$1"
 	VERSION="$2"
 	LOCAL_FOLDER="$3"
-	mkdir -p "${GVM_DIR}/${CANDIDATE}"
+	mkdir -p "${SDKMAN_DIR}/${CANDIDATE}"
 
 	echo "Linking ${CANDIDATE} ${VERSION} to ${LOCAL_FOLDER}"
-	ln -s "${LOCAL_FOLDER}" "${GVM_DIR}/${CANDIDATE}/${VERSION}"
+	ln -s "${LOCAL_FOLDER}" "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}"
 	echo "Done installing!"
 	echo ""
 }
@@ -104,10 +104,10 @@ function __sdkman_install_candidate_version {
 	__sdkman_download "${CANDIDATE}" "${VERSION}" || return 1
 	echo "Installing: ${CANDIDATE} ${VERSION}"
 
-	mkdir -p "${GVM_DIR}/${CANDIDATE}"
+	mkdir -p "${SDKMAN_DIR}/${CANDIDATE}"
 
-	unzip -oq "${GVM_DIR}/archives/${CANDIDATE}-${VERSION}.zip" -d "${GVM_DIR}/tmp/"
-	mv "${GVM_DIR}"/tmp/*-${VERSION} "${GVM_DIR}/${CANDIDATE}/${VERSION}"
+	unzip -oq "${SDKMAN_DIR}/archives/${CANDIDATE}-${VERSION}.zip" -d "${SDKMAN_DIR}/tmp/"
+	mv "${SDKMAN_DIR}"/tmp/*-${VERSION} "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}"
 	echo "Done installing!"
 	echo ""
 }
diff --git a/src/main/bash/sdkman-list.sh b/src/main/bash/sdkman-list.sh
index 604d2f7e..62dd4ada 100644
--- a/src/main/bash/sdkman-list.sh
+++ b/src/main/bash/sdkman-list.sh
@@ -19,7 +19,7 @@
 function __sdkman_build_version_csv {
 	CANDIDATE="$1"
 	CSV=""
-	for version in $(find "${GVM_DIR}/${CANDIDATE}" -maxdepth 1 -mindepth 1 -exec basename '{}' \; | sort); do
+	for version in $(find "${SDKMAN_DIR}/${CANDIDATE}" -maxdepth 1 -mindepth 1 -exec basename '{}' \; | sort); do
 		if [[ "${version}" != 'current' ]]; then
 			CSV="${version},${CSV}"
 		fi
@@ -33,18 +33,18 @@ function __sdkman_offline_list {
 	echo "------------------------------------------------------------"
 	echo "                                                            "
 
-	gvm_versions=($(echo ${CSV//,/ }))
-	for (( i=0 ; i <= ${#gvm_versions} ; i++ )); do
-		if [[ -n "${gvm_versions[${i}]}" ]]; then
-			if [[ "${gvm_versions[${i}]}" == "${CURRENT}" ]]; then
-				echo -e " > ${gvm_versions[${i}]}"
+	sdkman_versions=($(echo ${CSV//,/ }))
+	for (( i=0 ; i <= ${#sdkman_versions} ; i++ )); do
+		if [[ -n "${sdkman_versions[${i}]}" ]]; then
+			if [[ "${sdkman_versions[${i}]}" == "${CURRENT}" ]]; then
+				echo -e " > ${sdkman_versions[${i}]}"
 			else
-				echo -e " * ${gvm_versions[${i}]}"
+				echo -e " * ${sdkman_versions[${i}]}"
 			fi
 		fi
 	done
 
-	if [[ -z "${gvm_versions[@]}" ]]; then
+	if [[ -z "${sdkman_versions[@]}" ]]; then
 		echo "   None installed!"
 	fi
 
@@ -53,7 +53,7 @@ function __sdkman_offline_list {
 	echo "> - currently in use                                        "
 	echo "------------------------------------------------------------"
 
-	unset CSV gvm_versions
+	unset CSV sdkman_versions
 }
 
 function __sdkman_list {
@@ -62,10 +62,10 @@ function __sdkman_list {
 	__sdkman_build_version_csv "${CANDIDATE}"
 	__sdkman_determine_current_version "${CANDIDATE}"
 
-	if [[ "${GVM_AVAILABLE}" == "false" ]]; then
+	if [[ "${SDKMAN_AVAILABLE}" == "false" ]]; then
 		__sdkman_offline_list
 	else
-		FRAGMENT=$(curl -s "${GVM_SERVICE}/candidates/${CANDIDATE}/list?platform=${GVM_PLATFORM}&current=${CURRENT}&installed=${CSV}")
+		FRAGMENT=$(curl -s "${SDKMAN_SERVICE}/candidates/${CANDIDATE}/list?platform=${SDKMAN_PLATFORM}&current=${CURRENT}&installed=${CSV}")
 		echo "${FRAGMENT}"
 		unset FRAGMENT
 	fi
diff --git a/src/main/bash/sdkman-main.sh b/src/main/bash/sdkman-main.sh
index cfa83f4f..ca23b54d 100644
--- a/src/main/bash/sdkman-main.sh
+++ b/src/main/bash/sdkman-main.sh
@@ -51,13 +51,13 @@ function sdk {
 	#
 	__sdkman_default_environment_variables
 
-	mkdir -p "$GVM_DIR"
+	mkdir -p "$SDKMAN_DIR"
 
-    gvm_update_broadcast_or_force_offline
+    sdkman_update_broadcast_or_force_offline
 
-	# Load the gvm config if it exists.
-	if [ -f "${GVM_DIR}/etc/config" ]; then
-		source "${GVM_DIR}/etc/config"
+	# Load the sdkman config if it exists.
+	if [ -f "${SDKMAN_DIR}/etc/config" ]; then
+		source "${SDKMAN_DIR}/etc/config"
 	fi
 
  	# no command provided
@@ -68,13 +68,13 @@ function sdk {
 
 	# Check if it is a valid command
 	CMD_FOUND=""
-	CMD_TARGET="${GVM_DIR}/src/gvm-${COMMAND}.sh"
+	CMD_TARGET="${SDKMAN_DIR}/src/sdkman-${COMMAND}.sh"
 	if [[ -f "$CMD_TARGET" ]]; then
 		CMD_FOUND="$CMD_TARGET"
 	fi
 
 	# Check if it is a sourced function
-	CMD_TARGET="${GVM_DIR}/ext/gvm-${COMMAND}.sh"
+	CMD_TARGET="${SDKMAN_DIR}/ext/sdkman-${COMMAND}.sh"
 	if [[ -f "$CMD_TARGET" ]]; then
 		CMD_FOUND="$CMD_TARGET"
 	fi
@@ -86,8 +86,8 @@ function sdk {
 	fi
 
 	# Check whether the candidate exists
-	local gvm_valid_candidate=$(echo ${GVM_CANDIDATES[@]} | grep -w "$QUALIFIER")
-	if [[ -n "$QUALIFIER" && "$COMMAND" != "offline" && "$COMMAND" != "flush" && "$COMMAND" != "selfupdate" && -z "$gvm_valid_candidate" ]]; then
+	local sdkman_valid_candidate=$(echo ${SDKMAN_CANDIDATES[@]} | grep -w "$QUALIFIER")
+	if [[ -n "$QUALIFIER" && "$COMMAND" != "offline" && "$COMMAND" != "flush" && "$COMMAND" != "selfupdate" && -z "$sdkman_valid_candidate" ]]; then
 		echo -e "\nStop! $QUALIFIER is not a valid candidate."
 		return 1
 	fi
@@ -112,6 +112,6 @@ function sdk {
 
 	# Attempt upgrade after all is done
 	if [[ "$COMMAND" != "selfupdate" ]]; then
-	    __sdkman_auto_update "$GVM_REMOTE_VERSION" "$GVM_VERSION"
+	    __sdkman_auto_update "$SDKMAN_REMOTE_VERSION" "$SDKMAN_VERSION"
 	fi
 }
diff --git a/src/main/bash/sdkman-offline.sh b/src/main/bash/sdkman-offline.sh
index 898db4e9..4b2aad02 100644
--- a/src/main/bash/sdkman-offline.sh
+++ b/src/main/bash/sdkman-offline.sh
@@ -18,36 +18,36 @@
 
 function __sdkman_offline {
 	if [[ "$1" == "enable" ]]; then
-		GVM_FORCE_OFFLINE="true"
+		SDKMAN_FORCE_OFFLINE="true"
 		echo "Forced offline mode enabled."
 	fi
 	if [[ "$1" == "disable" ]]; then
-		GVM_FORCE_OFFLINE="false"
-		GVM_ONLINE="true"
+		SDKMAN_FORCE_OFFLINE="false"
+		SDKMAN_ONLINE="true"
 		echo "Online mode re-enabled!"
 	fi
 }
 
-function gvm_determine_offline {
+function sdkman_determine_offline {
     local input="$1"
 	if [[ -z "$input" ]]; then
-		GVM_ONLINE="false"
-		GVM_AVAILABLE="false"
+		SDKMAN_ONLINE="false"
+		SDKMAN_AVAILABLE="false"
 	else
-		GVM_ONLINE="true"
+		SDKMAN_ONLINE="true"
 	fi
 }
 
-function gvm_force_offline_on_proxy {
+function sdkman_force_offline_on_proxy {
 	local response="$1"
 	local detect_html="$(echo "$response" | tr '[:upper:]' '[:lower:]' | grep 'html')"
 	if [[ -n "$detect_html" ]]; then
-		echo "GVM can't reach the internet so going offline. Re-enable online with:"
+		echo "SDKMAN can't reach the internet so going offline. Re-enable online with:"
 		echo ""
-		echo "  $ gvm offline disable"
+		echo "  $ sdk offline disable"
 		echo ""
-		GVM_FORCE_OFFLINE="true"
+		SDKMAN_FORCE_OFFLINE="true"
     else
-        GVM_FORCE_OFFLINE="false"
+        SDKMAN_FORCE_OFFLINE="false"
 	fi
 }
diff --git a/src/main/bash/sdkman-outdated.sh b/src/main/bash/sdkman-outdated.sh
index cada2d2f..a0cf882e 100644
--- a/src/main/bash/sdkman-outdated.sh
+++ b/src/main/bash/sdkman-outdated.sh
@@ -5,19 +5,19 @@ function __sdkman_determine_outdated_version {
     candidate="$1"
 
     # Resolve local versions
-    local_versions="$(echo $(find "${GVM_DIR}/${candidate}" -maxdepth 1 -mindepth 1 -type d -exec basename '{}' \;) | sed -e "s/ /, /g" )"
+    local_versions="$(echo $(find "${SDKMAN_DIR}/${candidate}" -maxdepth 1 -mindepth 1 -type d -exec basename '{}' \;) | sed -e "s/ /, /g" )"
     if [ ${#local_versions} -eq 0 ]; then
         return 1
     fi
 
     # Resolve remote default version
-    remote_default_version="$(curl -s "${GVM_SERVICE}/candidates/${candidate}/default")"
+    remote_default_version="$(curl -s "${SDKMAN_SERVICE}/candidates/${candidate}/default")"
     if [ -z "$remote_default_version" ]; then
         return 2
     fi
 
     # Check outdated or not
-    if [ ! -d "${GVM_DIR}/${candidate}/${remote_default_version}" ]; then
+    if [ ! -d "${SDKMAN_DIR}/${candidate}/${remote_default_version}" ]; then
         echo "${candidate} (${local_versions} < ${remote_default_version})"
     fi
 }
@@ -29,7 +29,7 @@ function __sdkman_outdated {
         candidates=$1
     else
         all=true
-        candidates=${GVM_CANDIDATES[@]}
+        candidates=${SDKMAN_CANDIDATES[@]}
     fi
     installed_count=0
     outdated_count=0
diff --git a/src/main/bash/sdkman-selfupdate.sh b/src/main/bash/sdkman-selfupdate.sh
index 457f39bc..00618829 100644
--- a/src/main/bash/sdkman-selfupdate.sh
+++ b/src/main/bash/sdkman-selfupdate.sh
@@ -17,35 +17,35 @@
 #
 
 function __sdkman_selfupdate {
-    GVM_FORCE_SELFUPDATE="$1"
-	if [[ "$GVM_AVAILABLE" == "false" ]]; then
+    SDKMAN_FORCE_SELFUPDATE="$1"
+	if [[ "$SDKMAN_AVAILABLE" == "false" ]]; then
 		echo "$OFFLINE_MESSAGE"
 
-	elif [[ "$GVM_REMOTE_VERSION" == "$GVM_VERSION" && "$GVM_FORCE_SELFUPDATE" != "force" ]]; then
+	elif [[ "$SDKMAN_REMOTE_VERSION" == "$SDKMAN_VERSION" && "$SDKMAN_FORCE_SELFUPDATE" != "force" ]]; then
 		echo "No update available at this time."
 
 	else
-		curl -s "${GVM_SERVICE}/selfupdate" | bash
+		curl -s "${SDKMAN_SERVICE}/selfupdate" | bash
 	fi
-	unset GVM_FORCE_SELFUPDATE
+	unset SDKMAN_FORCE_SELFUPDATE
 }
 
 function __sdkman_auto_update {
 
-    local GVM_REMOTE_VERSION="$1"
-    local GVM_VERSION="$2"
+    local SDKMAN_REMOTE_VERSION="$1"
+    local SDKMAN_VERSION="$2"
 
-    GVM_DELAY_UPGRADE="${GVM_DIR}/var/delay_upgrade"
+    SDKMAN_DELAY_UPGRADE="${SDKMAN_DIR}/var/delay_upgrade"
 
-    if [[ -n "$(find "$GVM_DELAY_UPGRADE" -mtime +1)" && ( "$GVM_REMOTE_VERSION" != "$GVM_VERSION" ) ]]; then
+    if [[ -n "$(find "$SDKMAN_DELAY_UPGRADE" -mtime +1)" && ( "$SDKMAN_REMOTE_VERSION" != "$SDKMAN_VERSION" ) ]]; then
         echo ""
         echo ""
-        echo "ATTENTION: A new version of GVM is available..."
+        echo "ATTENTION: A new version of SDKman is available..."
         echo ""
-        echo "The current version is $GVM_REMOTE_VERSION, but you have $GVM_VERSION."
+        echo "The current version is $SDKMAN_REMOTE_VERSION, but you have $SDKMAN_VERSION."
         echo ""
 
-        if [[ "$gvm_auto_selfupdate" != "true" ]]; then
+        if [[ "$sdkman_auto_selfupdate" != "true" ]]; then
             echo -n "Would you like to upgrade now? (Y/n)"
             read upgrade
         fi
@@ -59,7 +59,7 @@ function __sdkman_auto_update {
             echo "Not upgrading today..."
         fi
 
-        touch "${GVM_DELAY_UPGRADE}"
+        touch "${SDKMAN_DELAY_UPGRADE}"
     fi
 
 }
\ No newline at end of file
diff --git a/src/main/bash/sdkman-uninstall.sh b/src/main/bash/sdkman-uninstall.sh
index b28adaf4..1f0f52a0 100644
--- a/src/main/bash/sdkman-uninstall.sh
+++ b/src/main/bash/sdkman-uninstall.sh
@@ -21,16 +21,16 @@ function __sdkman_uninstall {
 	VERSION="$2"
 	__sdkman_check_candidate_present "${CANDIDATE}" || return 1
 	__sdkman_check_version_present "${VERSION}" || return 1
-	CURRENT=$(readlink "${GVM_DIR}/${CANDIDATE}/current" | sed "s_${GVM_DIR}/${CANDIDATE}/__g")
-	if [[ -h "${GVM_DIR}/${CANDIDATE}/current" && ( "${VERSION}" == "${CURRENT}" ) ]]; then
+	CURRENT=$(readlink "${SDKMAN_DIR}/${CANDIDATE}/current" | sed "s_${SDKMAN_DIR}/${CANDIDATE}/__g")
+	if [[ -h "${SDKMAN_DIR}/${CANDIDATE}/current" && ( "${VERSION}" == "${CURRENT}" ) ]]; then
 		echo ""
 		echo "Unselecting ${CANDIDATE} ${VERSION}..."
-		unlink "${GVM_DIR}/${CANDIDATE}/current"
+		unlink "${SDKMAN_DIR}/${CANDIDATE}/current"
 	fi
 	echo ""
-	if [ -d "${GVM_DIR}/${CANDIDATE}/${VERSION}" ]; then
+	if [ -d "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" ]; then
 		echo "Uninstalling ${CANDIDATE} ${VERSION}..."
-		rm -rf "${GVM_DIR}/${CANDIDATE}/${VERSION}"
+		rm -rf "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}"
 	else
 		echo "${CANDIDATE} ${VERSION} is not installed."
 	fi
diff --git a/src/main/bash/sdkman-use.sh b/src/main/bash/sdkman-use.sh
index 89967872..653b5746 100644
--- a/src/main/bash/sdkman-use.sh
+++ b/src/main/bash/sdkman-use.sh
@@ -21,10 +21,10 @@ function __sdkman_use {
 	__sdkman_check_candidate_present "${CANDIDATE}" || return 1
 	__sdkman_determine_version "$2" || return 1
 
-	if [[ ! -d "${GVM_DIR}/${CANDIDATE}/${VERSION}" ]]; then
+	if [[ ! -d "${SDKMAN_DIR}/${CANDIDATE}/${VERSION}" ]]; then
 		echo ""
 		echo "Stop! ${CANDIDATE} ${VERSION} is not installed."
-		if [[ "${gvm_auto_answer}" != 'true' ]]; then
+		if [[ "${sdkman_auto_answer}" != 'true' ]]; then
 			echo -n "Do you want to install it now? (Y/n): "
 			read INSTALL
 		fi
@@ -37,17 +37,17 @@ function __sdkman_use {
 
 	# Just update the *_HOME and PATH for this shell.
 	UPPER_CANDIDATE=$(echo "${CANDIDATE}" | tr '[:lower:]' '[:upper:]')
-	export "${UPPER_CANDIDATE}_HOME"="${GVM_DIR}/${CANDIDATE}/${VERSION}"
+	export "${UPPER_CANDIDATE}_HOME"="${SDKMAN_DIR}/${CANDIDATE}/${VERSION}"
 
 	# Replace the current path for the candidate with the selected version.
 	if [[ "${solaris}" == true ]]; then
-		export PATH=$(echo $PATH | gsed -r "s!${GVM_DIR}/${CANDIDATE}/([^/]+)!${GVM_DIR}/${CANDIDATE}/${VERSION}!g")
+		export PATH=$(echo $PATH | gsed -r "s!${SDKMAN_DIR}/${CANDIDATE}/([^/]+)!${SDKMAN_DIR}/${CANDIDATE}/${VERSION}!g")
 
 	elif [[ "${darwin}" == true ]]; then
-		export PATH=$(echo $PATH | sed -E "s!${GVM_DIR}/${CANDIDATE}/([^/]+)!${GVM_DIR}/${CANDIDATE}/${VERSION}!g")
+		export PATH=$(echo $PATH | sed -E "s!${SDKMAN_DIR}/${CANDIDATE}/([^/]+)!${SDKMAN_DIR}/${CANDIDATE}/${VERSION}!g")
 
 	else
-		export PATH=$(echo $PATH | sed -r "s!${GVM_DIR}/${CANDIDATE}/([^/]+)!${GVM_DIR}/${CANDIDATE}/${VERSION}!g")
+		export PATH=$(echo $PATH | sed -r "s!${SDKMAN_DIR}/${CANDIDATE}/([^/]+)!${SDKMAN_DIR}/${CANDIDATE}/${VERSION}!g")
 	fi
 
 	echo ""
diff --git a/src/main/bash/sdkman-version.sh b/src/main/bash/sdkman-version.sh
index b1b6de1f..0563a89f 100644
--- a/src/main/bash/sdkman-version.sh
+++ b/src/main/bash/sdkman-version.sh
@@ -17,5 +17,5 @@
 #
 
 function __sdkman_version {
-	echo "Groovy enVironment Manager ${GVM_VERSION}"
+	echo "Groovy enVironment Manager ${SDKMAN_VERSION}"
 }
diff --git a/src/main/bash/selfupdate.sh b/src/main/bash/selfupdate.sh
index 786dcab5..758756f8 100755
--- a/src/main/bash/selfupdate.sh
+++ b/src/main/bash/selfupdate.sh
@@ -15,18 +15,18 @@
 #   limitations under the License.
 #
 
-function gvm_echo_debug {
-	if [[ "$GVM_DEBUG_MODE" == 'true' ]]; then
+function sdkman_echo_debug {
+	if [[ "$SDKMAN_DEBUG_MODE" == 'true' ]]; then
 		echo "$1"
 	fi
 }
 
 echo ""
-echo "Updating gvm..."
+echo "Updating SDKman..."
 
-GVM_VERSION="@GVM_VERSION@"
-if [ -z "${GVM_DIR}" ]; then
-	GVM_DIR="$HOME/.gvm"
+SDKMAN_VERSION="@SDKMAN_VERSION@"
+if [ -z "${SDKMAN_DIR}" ]; then
+	SDKMAN_DIR="$HOME/.sdkman"
 fi
 
 # OS specific support (must be 'true' or 'false').
@@ -48,92 +48,92 @@ case "$(uname)" in
         freebsd=true
 esac
 
-gvm_platform=$(uname)
-gvm_bin_folder="${GVM_DIR}/bin"
-gvm_tmp_zip="${GVM_DIR}/tmp/res-${GVM_VERSION}.zip"
-gvm_stage_folder="${GVM_DIR}/tmp/stage"
-gvm_src_folder="${GVM_DIR}/src"
+sdkman_platform=$(uname)
+sdkman_bin_folder="${SDKMAN_DIR}/bin"
+sdkman_tmp_zip="${SDKMAN_DIR}/tmp/res-${SDKMAN_VERSION}.zip"
+sdkman_stage_folder="${SDKMAN_DIR}/tmp/stage"
+sdkman_src_folder="${SDKMAN_DIR}/src"
 
-gvm_echo_debug "Purge existing scripts..."
-rm -rf "${gvm_bin_folder}"
-rm -rf "${gvm_src_folder}"
+sdkman_echo_debug "Purge existing scripts..."
+rm -rf "${sdkman_bin_folder}"
+rm -rf "${sdkman_src_folder}"
 
-gvm_echo_debug "Refresh directory structure..."
-mkdir -p "${GVM_DIR}/bin"
-mkdir -p "${GVM_DIR}/ext"
-mkdir -p "${GVM_DIR}/etc"
-mkdir -p "${GVM_DIR}/src"
-mkdir -p "${GVM_DIR}/var"
-mkdir -p "${GVM_DIR}/tmp"
+sdkman_echo_debug "Refresh directory structure..."
+mkdir -p "${SDKMAN_DIR}/bin"
+mkdir -p "${SDKMAN_DIR}/ext"
+mkdir -p "${SDKMAN_DIR}/etc"
+mkdir -p "${SDKMAN_DIR}/src"
+mkdir -p "${SDKMAN_DIR}/var"
+mkdir -p "${SDKMAN_DIR}/tmp"
 
 # prepare candidates
-GVM_CANDIDATES_CSV=$(curl -s "${GVM_SERVICE}/candidates")
-echo "$GVM_CANDIDATES_CSV" > "${GVM_DIR}/var/candidates"
+SDKMAN_CANDIDATES_CSV=$(curl -s "${SDKMAN_SERVICE}/candidates")
+echo "$SDKMAN_CANDIDATES_CSV" > "${SDKMAN_DIR}/var/candidates"
 
 # drop version token
-echo "$GVM_VERSION" > "${GVM_DIR}/var/version"
+echo "$SDKMAN_VERSION" > "${SDKMAN_DIR}/var/version"
 
 # create candidate directories
 # convert csv to array
 OLD_IFS="$IFS"
 IFS=","
-GVM_CANDIDATES=(${GVM_CANDIDATES_CSV})
+SDKMAN_CANDIDATES=(${SDKMAN_CANDIDATES_CSV})
 IFS="$OLD_IFS"
 
-for candidate in "${GVM_CANDIDATES[@]}"; do
+for candidate in "${SDKMAN_CANDIDATES[@]}"; do
     if [[ -n "$candidate" ]]; then
-        mkdir -p "${GVM_DIR}/${candidate}"
-        gvm_echo_debug "Created for ${candidate}: ${GVM_DIR}/${candidate}"
+        mkdir -p "${SDKMAN_DIR}/${candidate}"
+        sdkman_echo_debug "Created for ${candidate}: ${SDKMAN_DIR}/${candidate}"
     fi
 done
 
-if [[ -f "${GVM_DIR}/ext/config" ]]; then
-	gvm_echo_debug "Removing config from ext folder..."
-	rm -v "${GVM_DIR}/ext/config"
+if [[ -f "${SDKMAN_DIR}/ext/config" ]]; then
+	sdkman_echo_debug "Removing config from ext folder..."
+	rm -v "${SDKMAN_DIR}/ext/config"
 fi
 
-gvm_echo_debug "Prime the config file..."
-gvm_config_file="${GVM_DIR}/etc/config"
-touch "${gvm_config_file}"
-if [[ -z $(cat ${gvm_config_file} | grep 'gvm_auto_answer') ]]; then
-	echo "gvm_auto_answer=false" >> "${gvm_config_file}"
+sdkman_echo_debug "Prime the config file..."
+sdkman_config_file="${SDKMAN_DIR}/etc/config"
+touch "${sdkman_config_file}"
+if [[ -z $(cat ${sdkman_config_file} | grep 'sdkman_auto_answer') ]]; then
+	echo "sdkman_auto_answer=false" >> "${sdkman_config_file}"
 fi
 
-if [[ -z $(cat ${gvm_config_file} | grep 'gvm_auto_selfupdate') ]]; then
-	echo "gvm_auto_selfupdate=false" >> "${gvm_config_file}"
+if [[ -z $(cat ${sdkman_config_file} | grep 'sdkman_auto_selfupdate') ]]; then
+	echo "sdkman_auto_selfupdate=false" >> "${sdkman_config_file}"
 fi
 
-if [[ -z $(cat ${gvm_config_file} | grep 'gvm_insecure_ssl') ]]; then
-	echo "gvm_insecure_ssl=false" >> "${gvm_config_file}"
+if [[ -z $(cat ${sdkman_config_file} | grep 'sdkman_insecure_ssl') ]]; then
+	echo "sdkman_insecure_ssl=false" >> "${sdkman_config_file}"
 fi
 
-gvm_echo_debug "Download new scripts to: ${gvm_tmp_zip}"
-curl -s "${GVM_SERVICE}/res?platform=${gvm_platform}&purpose=selfupdate" > "${gvm_tmp_zip}"
+sdkman_echo_debug "Download new scripts to: ${sdkman_tmp_zip}"
+curl -s "${SDKMAN_SERVICE}/res?platform=${sdkman_platform}&purpose=selfupdate" > "${sdkman_tmp_zip}"
 
-gvm_echo_debug "Extract script archive..."
-gvm_echo_debug "Unziping scripts to: ${gvm_stage_folder}"
+sdkman_echo_debug "Extract script archive..."
+sdkman_echo_debug "Unziping scripts to: ${sdkman_stage_folder}"
 if [[ "${cygwin}" == 'true' ]]; then
-	gvm_echo_debug "Cygwin detected - normalizing paths for unzip..."
-	unzip -qo $(cygpath -w "${gvm_tmp_zip}") -d $(cygpath -w "${gvm_stage_folder}")
+	sdkman_echo_debug "Cygwin detected - normalizing paths for unzip..."
+	unzip -qo $(cygpath -w "${sdkman_tmp_zip}") -d $(cygpath -w "${sdkman_stage_folder}")
 else
-	unzip -qo "${gvm_tmp_zip}" -d "${gvm_stage_folder}"
+	unzip -qo "${sdkman_tmp_zip}" -d "${sdkman_stage_folder}"
 fi
 
-gvm_echo_debug "Moving gvm-init file to bin folder..."
-mv "${gvm_stage_folder}/gvm-init.sh" "${gvm_bin_folder}"
+sdkman_echo_debug "Moving sdkman-init file to bin folder..."
+mv "${sdkman_stage_folder}/sdkman-init.sh" "${sdkman_bin_folder}"
 
-gvm_echo_debug "Move remaining module scripts to src folder: ${gvm_src_folder}"
-mv "${gvm_stage_folder}"/gvm-* "${gvm_src_folder}"
+sdkman_echo_debug "Move remaining module scripts to src folder: ${sdkman_src_folder}"
+mv "${sdkman_stage_folder}"/sdkman-* "${sdkman_src_folder}"
 
-gvm_echo_debug "Clean up staging folder..."
-rm -rf "${gvm_stage_folder}"
+sdkman_echo_debug "Clean up staging folder..."
+rm -rf "${sdkman_stage_folder}"
 
 echo ""
 echo ""
-echo "Successfully upgraded GVM."
+echo "Successfully upgraded SDKman."
 echo ""
 echo "Please open a new terminal, or run the following in the existing one:"
 echo ""
-echo "    source \"${GVM_DIR}/bin/gvm-init.sh\""
+echo "    source \"${SDKMAN_DIR}/bin/sdkman-init.sh\""
 echo ""
 echo ""