diff --git a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg b/karaf/assembly/src/main/distribution/text/etc/org.apache.felix.karaf.shell.cfg
similarity index 94%
rename from karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
rename to karaf/assembly/src/main/distribution/text/etc/org.apache.felix.karaf.shell.cfg
index 98bbd57..0a2eafe 100644
--- a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
+++ b/karaf/assembly/src/main/distribution/text/etc/org.apache.felix.karaf.shell.cfg
@@ -19,5 +19,5 @@
 
 #
 sshPort=8101
-sshRealm=servicemix
-hostKey=${servicemix.base}/etc/host.key
+sshRealm=karaf
+hostKey=${karaf.base}/etc/host.key
diff --git a/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.logging.cfg b/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.logging.cfg
index 24ddea5..eca5c0e 100644
--- a/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.logging.cfg
+++ b/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.logging.cfg
@@ -32,5 +32,5 @@
 log4j.appender.out=org.apache.log4j.FileAppender
 log4j.appender.out.layout=org.apache.log4j.PatternLayout
 log4j.appender.out.layout.ConversionPattern=%d{ABSOLUTE} | %-5.5p | %-16.16t | %-32.32c{1} | %-32.32C %4L | %m%n
-log4j.appender.out.file=${servicemix.base}/data/log/servicemix.log
+log4j.appender.out.file=${karaf.base}/data/log/karaf.log
 log4j.appender.out.append=true
diff --git a/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.url.mvn.cfg b/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.url.mvn.cfg
index 6e50c3e..5615941 100644
--- a/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.url.mvn.cfg
+++ b/karaf/assembly/src/main/distribution/text/etc/org.ops4j.pax.url.mvn.cfg
@@ -55,7 +55,7 @@
 #
 # The following property value will add the system folder as a repo.
 #
-org.ops4j.pax.url.mvn.defaultRepositories=file:${servicemix.home}/system@snapshots
+org.ops4j.pax.url.mvn.defaultRepositories=file:${karaf.home}/system@snapshots
 
 #
 # Comma separated list of repositories scanned when resolving an artifact.
diff --git a/karaf/assembly/src/main/distribution/text/etc/system.properties b/karaf/assembly/src/main/distribution/text/etc/system.properties
index d82ce7c..42f026f 100644
--- a/karaf/assembly/src/main/distribution/text/etc/system.properties
+++ b/karaf/assembly/src/main/distribution/text/etc/system.properties
@@ -18,5 +18,5 @@
 ################################################################################
 
 org.ops4j.pax.logging.DefaultServiceLog.level=ERROR
-servicemix.name=root
+karaf.name=root
 xml.catalog.files=
diff --git a/karaf/assembly/src/main/distribution/unix-shell/bin/servicemix b/karaf/assembly/src/main/distribution/unix-shell/bin/karaf
similarity index 82%
rename from karaf/assembly/src/main/distribution/unix-shell/bin/servicemix
rename to karaf/assembly/src/main/distribution/unix-shell/bin/karaf
index b92e7ef..a5771c9 100755
--- a/karaf/assembly/src/main/distribution/unix-shell/bin/servicemix
+++ b/karaf/assembly/src/main/distribution/unix-shell/bin/karaf
@@ -108,29 +108,29 @@
 }
 
 locateHome() {
-    if [ "x$SERVICEMIX_HOME" != "x" ]; then
-        warn "Ignoring predefined value for SERVICEMIX_HOME"
+    if [ "x$KARAF_HOME" != "x" ]; then
+        warn "Ignoring predefined value for KARAF_HOME"
     fi
 
-    SERVICEMIX_HOME=`cd $DIRNAME/..; pwd`
-    if [ ! -d "$SERVICEMIX_HOME" ]; then
-        die "SERVICEMIX_HOME is not valid: $SERVICEMIX_HOME"
+    KARAF_HOME=`cd $DIRNAME/..; pwd`
+    if [ ! -d "$KARAF_HOME" ]; then
+        die "KARAF_HOME is not valid: $KARAF_HOME"
     fi
 }
 
 locateBase() {
-    if [ "x$SERVICEMIX_BASE" != "x" ]; then
-        if [ ! -d "$SERVICEMIX_BASE" ]; then
-            die "SERVICEMIX_BASE is not valid: $SERVICEMIX_BASE"
+    if [ "x$KARAF_BASE" != "x" ]; then
+        if [ ! -d "$KARAF_BASE" ]; then
+            die "KARAF_BASE is not valid: $KARAF_BASE"
         fi
     else
-        SERVICEMIX_BASE=$SERVICEMIX_HOME
+        KARAF_BASE=$KARAF_HOME
     fi
 }
 
 setupNativePath() {
     # Support for loading native libraries
-    LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:$SERVICEMIX_BASE/lib:$SERVICEMIX_HOME/lib"
+    LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:$KARAF_BASE/lib:$KARAF_HOME/lib"
 
     # For Cygwin, set PATH from LD_LIBRARY_PATH
     if $cygwin; then
@@ -186,7 +186,7 @@
     export JAVA_OPTS
 
     # Set Debug options if enabled
-    if [ "x$SERVICEMIX_DEBUG" != "x" ]; then
+    if [ "x$KARAF_DEBUG" != "x" ]; then
         # Use the defaults if JAVA_DEBUG_OPTS was not set
         if [ "x$JAVA_DEBUG_OPTS" = "x" ]; then
             JAVA_DEBUG_OPTS="$DEFAULT_JAVA_DEBUG_OPTS"
@@ -214,7 +214,7 @@
     fi
 
     # Add the jars in the lib dir
-    for file in $SERVICEMIX_HOME/lib/*.jar
+    for file in $KARAF_HOME/lib/*.jar
     do
         if [ -z "$CLASSPATH" ]; then
             CLASSPATH="$file"
@@ -238,10 +238,10 @@
     # Unlimit the number of file descriptors if possible
     unlimitFD
 
-    # Locate the ServiceMix home directory
+    # Locate the Karaf home directory
     locateHome
 
-    # Locate the ServiceMix base directory
+    # Locate the Karaf base directory
     locateBase
 
     # Setup the native library path
@@ -262,26 +262,26 @@
 }
 
 run() {
-    OPTS="-Dservicemix.startLocalConsole=true -Dservicemix.startRemoteShell=true"
+    OPTS="-Dkaraf.startLocalConsole=true -Dkaraf.startRemoteShell=true"
     case "$1" in
         'console')
             shift
             ;;
         'server')
-            OPTS="-Dservicemix.startLocalConsole=false -Dservicemix.startRemoteShell=true"
+            OPTS="-Dkaraf.startLocalConsole=false -Dkaraf.startRemoteShell=true"
             shift
             ;;
         'client')
-            OPTS="-Dservicemix.startLocalConsole=true -Dservicemix.startRemoteShell=false"
+            OPTS="-Dkaraf.startLocalConsole=true -Dkaraf.startRemoteShell=false"
             shift
             ;;
     esac
 
     if $cygwin; then
-        SERVICEMIX_HOME=`cygpath --path --windows "$SERVICEMIX_HOME"`
-        SERVICEMIX_BASE=`cygpath --path --windows "$SERVICEMIX_BASE"`
+        KARAF_HOME=`cygpath --path --windows "$KARAF_HOME"`
+        KARAF_BASE=`cygpath --path --windows "$KARAF_BASE"`
     fi
-    exec $JAVA $JAVA_OPTS -Dservicemix.home="$SERVICEMIX_HOME" -Dservicemix.base="$SERVICEMIX_BASE" -Djava.util.logging.config.file=$SERVICEMIX_BASE/etc/java.util.logging.properties $OPTS -classpath "$CLASSPATH" org.apache.felix.karaf.main.Main $*
+    exec $JAVA $JAVA_OPTS -Dkaraf.home="$KARAF_HOME" -Dkaraf.base="$KARAF_BASE" -Djava.util.logging.config.file=$KARAF_BASE/etc/java.util.logging.properties $OPTS -classpath "$CLASSPATH" org.apache.felix.karaf.main.Main $*
 }
 
 main() {
diff --git a/karaf/assembly/src/main/distribution/windows-text/bin/karaf.bat b/karaf/assembly/src/main/distribution/windows-text/bin/karaf.bat
new file mode 100755
index 0000000..475663b
--- /dev/null
+++ b/karaf/assembly/src/main/distribution/windows-text/bin/karaf.bat
@@ -0,0 +1,166 @@
+@echo off
+rem
+rem
+rem    Licensed to the Apache Software Foundation (ASF) under one or more
+rem    contributor license agreements.  See the NOTICE file distributed with
+rem    this work for additional information regarding copyright ownership.
+rem    The ASF licenses this file to You under the Apache License, Version 2.0
+rem    (the "License"); you may not use this file except in compliance with
+rem    the License.  You may obtain a copy of the License at
+rem
+rem       http://www.apache.org/licenses/LICENSE-2.0
+rem
+rem    Unless required by applicable law or agreed to in writing, software
+rem    distributed under the License is distributed on an "AS IS" BASIS,
+rem    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+rem    See the License for the specific language governing permissions and
+rem    limitations under the License.
+rem
+rem 
+rem $Id: servicemix.bat 979 2005-11-30 22:50:55Z bsnyder $
+rem 
+
+if not "%ECHO%" == "" echo %ECHO%
+
+setlocal
+set DIRNAME=%~dp0%
+set PROGNAME=%~nx0%
+set ARGS=%*
+
+title Karaf
+
+goto BEGIN
+
+:warn
+    echo %PROGNAME%: %*
+goto :EOF
+
+:BEGIN
+
+rem # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+if not "%KARAF_HOME%" == "" (
+    call :warn Ignoring predefined value for KARAF_HOME
+)
+set KARAF_HOME=%DIRNAME%..
+if not exist "%KARAF_HOME%" (
+    call :warn KARAF_HOME is not valid: %KARAF_HOME%
+    goto END
+)
+
+if not "%KARAF_BASE%" == "" (
+    if not exist "%KARAF_BASE%" (
+       call :warn KARAF_BASE is not valid: %KARAF_BASE%
+       goto END
+    )
+)
+if "%KARAF_BASE%" == "" (
+  set KARAF_BASE=%KARAF_HOME%
+)
+
+set LOCAL_CLASSPATH=%CLASSPATH%
+set DEFAULT_JAVA_OPTS=-server -Xmx512M -Dderby.system.home="%KARAF_BASE%\data\derby" -Dderby.storage.fileSyncTransactionLog=true -Dcom.sun.management.jmxremote
+set CLASSPATH=%LOCAL_CLASSPATH%;%KARAF_BASE%\conf
+set DEFAULT_JAVA_DEBUG_OPTS=-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005
+
+if "%LOCAL_CLASSPATH%" == "" goto :KARAF_CLASSPATH_EMPTY
+    set CLASSPATH=%LOCAL_CLASSPATH%;%KARAF_BASE%\conf
+    goto :KARAF_CLASSPATH_END
+:KARAF_CLASSPATH_EMPTY
+    set CLASSPATH=%KARAF_BASE%\conf
+:KARAF_CLASSPATH_END
+
+rem Setup Karaf Home
+if exist "%KARAF_HOME%\conf\karaf-rc.cmd" call %KARAF_HOME%\conf\karaf-rc.cmd
+if exist "%HOME%\karaf-rc.cmd" call %HOME%\karaf-rc.cmd
+
+rem Support for loading native libraries
+set PATH=%PATH%;%KARAF_BASE%\lib;%KARAF_HOME%\lib
+
+rem Setup the Java Virtual Machine
+if not "%JAVA%" == "" goto :Check_JAVA_END
+    set JAVA=java
+    if "%JAVA_HOME%" == "" call :warn JAVA_HOME not set; results may vary
+    if not "%JAVA_HOME%" == "" set JAVA=%JAVA_HOME%\bin\java
+    if not exist "%JAVA_HOME%" (
+        call :warn JAVA_HOME is not valid: "%JAVA_HOME%"
+        goto END
+    )
+:Check_JAVA_END
+
+if "%JAVA_OPTS%" == "" set JAVA_OPTS=%DEFAULT_JAVA_OPTS%
+
+if "%KARAF_DEBUG%" == "" goto :KARAF_DEBUG_END
+    rem Use the defaults if JAVA_DEBUG_OPTS was not set
+    if "%JAVA_DEBUG_OPTS%" == "" set JAVA_DEBUG_OPTS=%DEFAULT_JAVA_DEBUG_OPTS%
+    
+    set "JAVA_OPTS=%JAVA_DEBUG_OPTS% %JAVA_OPTS%"
+    call :warn Enabling Java debug options: %JAVA_DEBUG_OPTS%
+:KARAF_DEBUG_END
+
+if "%KARAF_PROFILER%" == "" goto :KARAF_PROFILER_END
+    set KARAF_PROFILER_SCRIPT=%KARAF_HOME%\conf\profiler\%KARAF_PROFILER%.cmd
+    
+    if exist "%KARAF_PROFILER_SCRIPT%" goto :KARAF_PROFILER_END
+    call :warn Missing configuration for profiler '%KARAF_PROFILER%': %KARAF_PROFILER_SCRIPT%
+    goto END
+:KARAF_PROFILER_END
+
+rem Setup the classpath
+pushd "%KARAF_HOME%\lib"
+for %%G in (*.*) do call:APPEND_TO_CLASSPATH %%G
+popd
+goto CLASSPATH_END
+
+: APPEND_TO_CLASSPATH
+set filename=%~1
+set suffix=%filename:~-4%
+if %suffix% equ .jar set CLASSPATH=%CLASSPATH%;%KARAF_HOME%\lib\%filename%
+goto :EOF
+
+:CLASSPATH_END
+
+rem Execute the JVM or the load the profiler
+if "%KARAF_PROFILER%" == "" goto :RUN
+    rem Execute the profiler if it has been configured
+    call :warn Loading profiler script: %KARAF_PROFILER_SCRIPT%
+    call %KARAF_PROFILER_SCRIPT%
+
+:RUN
+    SET OPTS=-Dkaraf.startLocalConsole=true -Dkaraf.startRemoteShell=true
+    SET SHIFT=false
+    if "%1" == "console" goto :EXECUTE_CONSOLE
+    if "%1" == "server" goto :EXECUTE_SERVER
+    if "%1" == "client" goto :EXECUTE_CLIENT
+    goto :EXECUTE
+
+:EXECUTE_CONSOLE
+    SET SHIFT=true
+    goto :EXECUTE    
+
+:EXECUTE_SERVER
+    SET OPTS="-Dkaraf.startLocalConsole=false -Dkaraf.startRemoteShell=true"
+    SET SHIFT=true
+    goto :EXECUTE
+
+:EXECUTE_CLIENT
+    SET OPTS="-Dkaraf.startLocalConsole=true -Dkaraf.startRemoteShell=false"
+    SET SHIFT=true
+    goto :EXECUTE
+
+:EXECUTE
+    if "%SHIFT%" == "true" SET ARGS=%2 %3 %4 %5 %6 %7 %8
+    if not "%SHIFT%" == "true" SET ARGS=%1 %2 %3 %4 %5 %6 %7 %8    
+    rem Execute the Java Virtual Machine
+    "%JAVA%" %JAVA_OPTS% %OPTS% -classpath "%CLASSPATH%" -Dkaraf.home="%KARAF_HOME%" -Dkaraf.base="%KARAF_BASE%" -Djava.util.logging.config.file=%KARAF_BASE%\etc\java.util.logging.properties org.apache.felix.karaf.main.Main %ARGS%
+
+rem # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+:END
+
+endlocal
+
+if not "%PAUSE%" == "" pause
+
+:END_NO_PAUSE
+
diff --git a/karaf/assembly/src/main/distribution/windows-text/bin/servicemix.bat b/karaf/assembly/src/main/distribution/windows-text/bin/servicemix.bat
deleted file mode 100755
index e41f784..0000000
--- a/karaf/assembly/src/main/distribution/windows-text/bin/servicemix.bat
+++ /dev/null
@@ -1,166 +0,0 @@
-@echo off
-rem
-rem
-rem    Licensed to the Apache Software Foundation (ASF) under one or more
-rem    contributor license agreements.  See the NOTICE file distributed with
-rem    this work for additional information regarding copyright ownership.
-rem    The ASF licenses this file to You under the Apache License, Version 2.0
-rem    (the "License"); you may not use this file except in compliance with
-rem    the License.  You may obtain a copy of the License at
-rem
-rem       http://www.apache.org/licenses/LICENSE-2.0
-rem
-rem    Unless required by applicable law or agreed to in writing, software
-rem    distributed under the License is distributed on an "AS IS" BASIS,
-rem    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-rem    See the License for the specific language governing permissions and
-rem    limitations under the License.
-rem
-rem 
-rem $Id: servicemix.bat 979 2005-11-30 22:50:55Z bsnyder $
-rem 
-
-if not "%ECHO%" == "" echo %ECHO%
-
-setlocal
-set DIRNAME=%~dp0%
-set PROGNAME=%~nx0%
-set ARGS=%*
-
-title ServiceMix
-
-goto BEGIN
-
-:warn
-    echo %PROGNAME%: %*
-goto :EOF
-
-:BEGIN
-
-rem # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-
-if not "%SERVICEMIX_HOME%" == "" (
-    call :warn Ignoring predefined value for SERVICEMIX_HOME
-)
-set SERVICEMIX_HOME=%DIRNAME%..
-if not exist "%SERVICEMIX_HOME%" (
-    call :warn SERVICEMIX_HOME is not valid: %SERVICEMIX_HOME%
-    goto END
-)
-
-if not "%SERVICEMIX_BASE%" == "" (
-    if not exist "%SERVICEMIX_BASE%" (
-       call :warn SERVICEMIX_BASE is not valid: %SERVICEMIX_BASE%
-       goto END
-    )
-)
-if "%SERVICEMIX_BASE%" == "" (
-  set SERVICEMIX_BASE=%SERVICEMIX_HOME%
-)
-
-set LOCAL_CLASSPATH=%CLASSPATH%
-set DEFAULT_JAVA_OPTS=-server -Xmx512M -Dderby.system.home="%SERVICEMIX_BASE%\data\derby" -Dderby.storage.fileSyncTransactionLog=true -Dcom.sun.management.jmxremote
-set CLASSPATH=%LOCAL_CLASSPATH%;%SERVICEMIX_BASE%\conf
-set DEFAULT_JAVA_DEBUG_OPTS=-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005
-
-if "%LOCAL_CLASSPATH%" == "" goto :SERVICEMIX_CLASSPATH_EMPTY
-    set CLASSPATH=%LOCAL_CLASSPATH%;%SERVICEMIX_BASE%\conf
-    goto :SERVICEMIX_CLASSPATH_END
-:SERVICEMIX_CLASSPATH_EMPTY
-    set CLASSPATH=%SERVICEMIX_BASE%\conf
-:SERVICEMIX_CLASSPATH_END
-
-rem Setup Servicemix Home
-if exist "%SERVICEMIX_HOME%\conf\servicemix-rc.cmd" call %SERVICEMIX_HOME%\conf\servicemix-rc.cmd
-if exist "%HOME%\servicemix-rc.cmd" call %HOME%\servicemix-rc.cmd
-
-rem Support for loading native libraries
-set PATH=%PATH%;%SERVICEMIX_BASE%\lib;%SERVICEMIX_HOME%\lib
-
-rem Setup the Java Virtual Machine
-if not "%JAVA%" == "" goto :Check_JAVA_END
-    set JAVA=java
-    if "%JAVA_HOME%" == "" call :warn JAVA_HOME not set; results may vary
-    if not "%JAVA_HOME%" == "" set JAVA=%JAVA_HOME%\bin\java
-    if not exist "%JAVA_HOME%" (
-        call :warn JAVA_HOME is not valid: "%JAVA_HOME%"
-        goto END
-    )
-:Check_JAVA_END
-
-if "%JAVA_OPTS%" == "" set JAVA_OPTS=%DEFAULT_JAVA_OPTS%
-
-if "%SERVICEMIX_DEBUG%" == "" goto :SERVICEMIX_DEBUG_END
-    rem Use the defaults if JAVA_DEBUG_OPTS was not set
-    if "%JAVA_DEBUG_OPTS%" == "" set JAVA_DEBUG_OPTS=%DEFAULT_JAVA_DEBUG_OPTS%
-    
-    set "JAVA_OPTS=%JAVA_DEBUG_OPTS% %JAVA_OPTS%"
-    call :warn Enabling Java debug options: %JAVA_DEBUG_OPTS%
-:SERVICEMIX_DEBUG_END
-
-if "%SERVICEMIX_PROFILER%" == "" goto :SERVICEMIX_PROFILER_END
-    set SERVICEMIX_PROFILER_SCRIPT=%SERVICEMIX_HOME%\conf\profiler\%SERVICEMIX_PROFILER%.cmd
-    
-    if exist "%SERVICEMIX_PROFILER_SCRIPT%" goto :SERVICEMIX_PROFILER_END
-    call :warn Missing configuration for profiler '%SERVICEMIX_PROFILER%': %SERVICEMIX_PROFILER_SCRIPT%
-    goto END
-:SERVICEMIX_PROFILER_END
-
-rem Setup the classpath
-pushd "%SERVICEMIX_HOME%\lib"
-for %%G in (*.*) do call:APPEND_TO_CLASSPATH %%G
-popd
-goto CLASSPATH_END
-
-: APPEND_TO_CLASSPATH
-set filename=%~1
-set suffix=%filename:~-4%
-if %suffix% equ .jar set CLASSPATH=%CLASSPATH%;%SERVICEMIX_HOME%\lib\%filename%
-goto :EOF
-
-:CLASSPATH_END
-
-rem Execute the JVM or the load the profiler
-if "%SERVICEMIX_PROFILER%" == "" goto :RUN
-    rem Execute the profiler if it has been configured
-    call :warn Loading profiler script: %SERVICEMIX_PROFILER_SCRIPT%
-    call %SERVICEMIX_PROFILER_SCRIPT%
-
-:RUN
-    SET OPTS=-Dservicemix.startLocalConsole=true -Dservicemix.startRemoteShell=true
-    SET SHIFT=false
-    if "%1" == "console" goto :EXECUTE_CONSOLE
-    if "%1" == "server" goto :EXECUTE_SERVER
-    if "%1" == "client" goto :EXECUTE_CLIENT
-    goto :EXECUTE
-
-:EXECUTE_CONSOLE
-    SET SHIFT=true
-    goto :EXECUTE    
-
-:EXECUTE_SERVER
-    SET OPTS="-Dservicemix.startLocalConsole=false -Dservicemix.startRemoteShell=true"
-    SET SHIFT=true
-    goto :EXECUTE
-
-:EXECUTE_CLIENT
-    SET OPTS="-Dservicemix.startLocalConsole=true -Dservicemix.startRemoteShell=false"
-    SET SHIFT=true
-    goto :EXECUTE
-
-:EXECUTE
-    if "%SHIFT%" == "true" SET ARGS=%2 %3 %4 %5 %6 %7 %8
-    if not "%SHIFT%" == "true" SET ARGS=%1 %2 %3 %4 %5 %6 %7 %8    
-    rem Execute the Java Virtual Machine
-    "%JAVA%" %JAVA_OPTS% %OPTS% -classpath "%CLASSPATH%" -Dservicemix.home="%SERVICEMIX_HOME%" -Dservicemix.base="%SERVICEMIX_BASE%" -Djava.util.logging.config.file=%SERVICEMIX_BASE%\etc\java.util.logging.properties org.apache.felix.karaf.main.Main %ARGS%
-
-rem # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-
-:END
-
-endlocal
-
-if not "%PAUSE%" == "" pause
-
-:END_NO_PAUSE
-
diff --git a/karaf/assembly/src/main/filtered-resources/etc/config.properties b/karaf/assembly/src/main/filtered-resources/etc/config.properties
index abdabca..b8b1457 100644
--- a/karaf/assembly/src/main/filtered-resources/etc/config.properties
+++ b/karaf/assembly/src/main/filtered-resources/etc/config.properties
@@ -52,10 +52,10 @@
 #
 # FileMonitor properties
 #
-org.apache.servicemix.filemonitor.configDir        = ${servicemix.base}/etc
-org.apache.servicemix.filemonitor.monitorDir       = ${servicemix.base}/deploy
-org.apache.servicemix.filemonitor.generatedJarDir  = ${servicemix.base}/data/generated-bundles
-org.apache.servicemix.filemonitor.scanInterval     = 500
+org.apache.felix.karaf.filemonitor.configDir        = ${karaf.base}/etc
+org.apache.felix.karaf.filemonitor.monitorDir       = ${karaf.base}/deploy
+org.apache.felix.karaf.filemonitor.generatedJarDir  = ${karaf.base}/data/generated-bundles
+org.apache.felix.karaf.filemonitor.scanInterval     = 500
 
 
 #
diff --git a/karaf/demos/smx4web/src/main/java/org/apache/servicemix/smx4webex/WebAppListener.java b/karaf/demos/smx4web/src/main/java/org/apache/servicemix/smx4webex/WebAppListener.java
index b183b64..d0cda99 100644
--- a/karaf/demos/smx4web/src/main/java/org/apache/servicemix/smx4webex/WebAppListener.java
+++ b/karaf/demos/smx4web/src/main/java/org/apache/servicemix/smx4webex/WebAppListener.java
@@ -32,10 +32,10 @@
 			System.err.println("contextInitialized");
 			String root = new File(sce.getServletContext().getRealPath("/") + "WEB-INF/servicemix").getAbsolutePath();
 			System.err.println("Root: " + root);
-			System.setProperty("servicemix.home", root);
-			System.setProperty("servicemix.base", root);
-			System.setProperty("servicemix.startLocalConsole", "false");
-			System.setProperty("servicemix.startRemoteShell", "true");
+			System.setProperty("karaf.home", root);
+			System.setProperty("karaf.base", root);
+			System.setProperty("karaf.startLocalConsole", "false");
+			System.setProperty("karaf.startRemoteShell", "true");
 			main = new Main(new String[0]);
 			main.launch();
 		} catch (Exception e) {
diff --git a/karaf/deployer/filemonitor/src/main/java/org/apache/felix/karaf/deployer/filemonitor/FileMonitor.java b/karaf/deployer/filemonitor/src/main/java/org/apache/felix/karaf/deployer/filemonitor/FileMonitor.java
index ac00c45..f49b6a8 100644
--- a/karaf/deployer/filemonitor/src/main/java/org/apache/felix/karaf/deployer/filemonitor/FileMonitor.java
+++ b/karaf/deployer/filemonitor/src/main/java/org/apache/felix/karaf/deployer/filemonitor/FileMonitor.java
@@ -70,10 +70,10 @@
  */
 public class FileMonitor {
 
-    public final static String CONFIG_DIR = "org.apache.servicemix.filemonitor.configDir";
-    public final static String DEPLOY_DIR = "org.apache.servicemix.filemonitor.monitorDir";
-    public final static String GENERATED_JAR_DIR = "org.apache.servicemix.filemonitor.generatedJarDir";
-    public final static String SCAN_INTERVAL = "org.apache.servicemix.filemonitor.scanInterval";
+    public final static String CONFIG_DIR = "org.apache.felix.karaf.filemonitor.configDir";
+    public final static String DEPLOY_DIR = "org.apache.felix.karaf.filemonitor.monitorDir";
+    public final static String GENERATED_JAR_DIR = "org.apache.felix.karaf.filemonitor.generatedJarDir";
+    public final static String SCAN_INTERVAL = "org.apache.felix.karaf.filemonitor.scanInterval";
     public final static String PREFERENCE_KEY = "FileMonitor";
 
     protected static final String ALIAS_KEY = "_alias_factory_pid";
@@ -98,7 +98,7 @@
     private String pid;
 
     public FileMonitor() {
-        String base = System.getProperty("servicemix.base", ".");
+        String base = System.getProperty("karaf.base", ".");
         configDir = new File(base, "etc");
         deployDir = new File(base, "deploy");
         generateDir = new File(base, "data/generated-bundles");
diff --git a/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/AdminServiceImpl.java b/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/AdminServiceImpl.java
index 6e39bfd..7c7244d 100644
--- a/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/AdminServiceImpl.java
+++ b/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/AdminServiceImpl.java
@@ -125,12 +125,12 @@
         copyResourceToDir(serviceMixBase, "etc/startup.properties", true);
 
         HashMap<String, String> props = new HashMap<String, String>();
-        props.put("${servicemix.name}", name);
-        props.put("${servicemix.home}", System.getProperty("servicemix.home"));
-        props.put("${servicemix.base}", serviceMixBase.getPath());
-        props.put("${servicemix.sshPort}", Integer.toString(sshPort));
+        props.put("${karaf.name}", name);
+        props.put("${karaf.home}", System.getProperty("karaf.home"));
+        props.put("${karaf.base}", serviceMixBase.getPath());
+        props.put("${karaf.sshPort}", Integer.toString(sshPort));
         copyFilteredResourceToDir(serviceMixBase, "etc/system.properties", props);
-        copyFilteredResourceToDir(serviceMixBase, "etc/org.apache.servicemix.shell.cfg", props);
+        copyFilteredResourceToDir(serviceMixBase, "etc/org.apache.felix.karaf.shell.cfg", props);
         if( System.getProperty("os.name").startsWith("Win") ) {
             copyFilteredResourceToDir(serviceMixBase, "bin/servicemix.bat", props);
         } else {
diff --git a/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/InstanceImpl.java b/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/InstanceImpl.java
index 9981e67..7640249 100644
--- a/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/InstanceImpl.java
+++ b/karaf/gshell/gshell-admin/src/main/java/org/apache/felix/karaf/gshell/admin/internal/InstanceImpl.java
@@ -72,7 +72,7 @@
     public int getPort() throws Exception {
         InputStream is = null;
         try {
-            File f = new File(location, "etc/org.apache.servicemix.shell.cfg");
+            File f = new File(location, "etc/org.apache.felix.karaf.shell.cfg");
             is = new FileInputStream(f);
             Properties props = new Properties();
             props.load(is);
@@ -91,7 +91,7 @@
             throw new IllegalStateException("Instance not stopped");
         }
         Properties props = new Properties();
-        File f = new File(location, "etc/org.apache.servicemix.shell.cfg");
+        File f = new File(location, "etc/org.apache.felix.karaf.shell.cfg");
         InputStream is = new FileInputStream(f);
         try {
             props.load(is);
@@ -115,7 +115,7 @@
         if (javaOpts == null) {
             javaOpts = "-server -Xmx512M -Dcom.sun.management.jmxremote";
         }
-        File libDir = new File(System.getProperty("servicemix.home"), "lib");
+        File libDir = new File(System.getProperty("karaf.home"), "lib");
         File[] jars = libDir.listFiles(new FilenameFilter() {
             public boolean accept(File dir, String name) {
                 return name.endsWith(".jar");
@@ -130,10 +130,10 @@
         }
         String command = new File(System.getProperty("java.home"), ScriptUtils.isWindows() ? "bin\\java.exe" : "bin/java").getCanonicalPath()
                 + " " + javaOpts
-                + " -Dservicemix.home=\"" + System.getProperty("servicemix.home") + "\""
-                + " -Dservicemix.base=\"" + new File(location).getCanonicalPath() + "\""
-                + " -Dservicemix.startLocalConsole=false"
-                + " -Dservicemix.startRemoteShell=true"
+                + " -Dkaraf.home=\"" + System.getProperty("karaf.home") + "\""
+                + " -Dkaraf.base=\"" + new File(location).getCanonicalPath() + "\""
+                + " -Dkaraf.startLocalConsole=false"
+                + " -Dkaraf.startRemoteShell=true"
                 + " -classpath " + classpath.toString()
                 + " org.apache.felix.karaf.main.Main";
         LOG.debug("Starting instance with command: " + command);
diff --git a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf
similarity index 89%
copy from karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
copy to karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf
index 98bbd57..180092b 100644
--- a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf
@@ -1,3 +1,4 @@
+#!/bin/sh
 ################################################################################
 #
 #    Licensed to the Apache Software Foundation (ASF) under one or more
@@ -17,7 +18,8 @@
 #
 ################################################################################
 
-#
-sshPort=8101
-sshRealm=servicemix
-hostKey=${servicemix.base}/etc/host.key
+KARAF_HOME=${karaf.home}
+KARAF_BASE=${karaf.base}
+
+export KARAF_BASE
+${KARAF_HOME}/bin/karaf "$*"
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix.bat b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf.bat
similarity index 89%
rename from karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix.bat
rename to karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf.bat
index 13c155a..1358ba7 100644
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix.bat
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/karaf.bat
@@ -18,8 +18,8 @@
 REM 
 REM =========================================================================
 
-SET SERVICEMIX_BASE=${servicemix.base}
+SET KARAF_BASE=${karaf.base}
 SETLOCAL
-SET SERVICEMIX_HOME=${servicemix.home}
+SET KARAF_HOME=${karaf.home}
 
-%SERVICEMIX_HOME%\bin\servicemix.bat %*
+%KARAF_HOME%\bin\karaf.bat %*
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix
deleted file mode 100644
index e52bc53..0000000
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/bin/servicemix
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/sh
-################################################################################
-#
-#    Licensed to the Apache Software Foundation (ASF) under one or more
-#    contributor license agreements.  See the NOTICE file distributed with
-#    this work for additional information regarding copyright ownership.
-#    The ASF licenses this file to You under the Apache License, Version 2.0
-#    (the "License"); you may not use this file except in compliance with
-#    the License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-################################################################################
-
-SERVICEMIX_HOME=${servicemix.home}
-SERVICEMIX_BASE=${servicemix.base}
-
-export SERVICEMIX_BASE
-${SERVICEMIX_HOME}/bin/servicemix "$*"
diff --git a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.felix.karaf.shell.cfg
similarity index 88%
copy from karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
copy to karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.felix.karaf.shell.cfg
index 98bbd57..8b83a07 100644
--- a/karaf/assembly/src/main/distribution/text/etc/org.apache.servicemix.shell.cfg
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.felix.karaf.shell.cfg
@@ -18,6 +18,6 @@
 ################################################################################
 
 #
-sshPort=8101
-sshRealm=servicemix
-hostKey=${servicemix.base}/etc/host.key
+startLocalConsole=${karaf.startLocalConsole}
+startRemoteShell=${karaf.startRemoteShell}
+sshPort=${karaf.sshPort}
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.servicemix.shell.cfg b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.servicemix.shell.cfg
deleted file mode 100644
index e6a8fd2..0000000
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.apache.servicemix.shell.cfg
+++ /dev/null
@@ -1,23 +0,0 @@
-################################################################################
-#
-#    Licensed to the Apache Software Foundation (ASF) under one or more
-#    contributor license agreements.  See the NOTICE file distributed with
-#    this work for additional information regarding copyright ownership.
-#    The ASF licenses this file to You under the Apache License, Version 2.0
-#    (the "License"); you may not use this file except in compliance with
-#    the License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-################################################################################
-
-#
-startLocalConsole=${servicemix.startLocalConsole}
-startRemoteShell=${servicemix.startRemoteShell}
-sshPort=${servicemix.sshPort}
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.logging.cfg b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.logging.cfg
index 24ddea5..fcc4ea9 100644
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.logging.cfg
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.logging.cfg
@@ -32,5 +32,5 @@
 log4j.appender.out=org.apache.log4j.FileAppender
 log4j.appender.out.layout=org.apache.log4j.PatternLayout
 log4j.appender.out.layout.ConversionPattern=%d{ABSOLUTE} | %-5.5p | %-16.16t | %-32.32c{1} | %-32.32C %4L | %m%n
-log4j.appender.out.file=${servicemix.base}/data/log/servicemix.log
+log4j.appender.out.file=${karaf.base}/data/log/servicemix.log
 log4j.appender.out.append=true
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.url.mvn.cfg b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.url.mvn.cfg
index d0317cd..3f1ac71 100644
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.url.mvn.cfg
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/org.ops4j.pax.url.mvn.cfg
@@ -55,7 +55,7 @@
 #
 # The following property value will add the system folder as a repo.
 #
-org.ops4j.pax.url.mvn.defaultRepositories=file:${servicemix.home}/system@snapshots,file:${servicemix.base}/system@snapshots
+org.ops4j.pax.url.mvn.defaultRepositories=file:${karaf.home}/system@snapshots,file:${karaf.base}/system@snapshots
 
 #
 # Comma separated list of repositories scanned when resolving an artifact.
@@ -70,4 +70,4 @@
 #
 # The following property value will add the system folders as a repo.
 #
-org.ops4j.pax.url.mvn.repositories=file:${servicemix.base}/system@snapshots,file:${user.home}/.m2/repository@snapshots,http://repo1.maven.org/maven2,http://people.apache.org/repo/m2-snapshot-repository@snapshots@noreleases,http://svn.apache.org/repos/asf/servicemix/m2-repo
+org.ops4j.pax.url.mvn.repositories=file:${karaf.base}/system@snapshots,file:${user.home}/.m2/repository@snapshots,http://repo1.maven.org/maven2,http://people.apache.org/repo/m2-snapshot-repository@snapshots@noreleases,http://svn.apache.org/repos/asf/servicemix/m2-repo
diff --git a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/system.properties b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/system.properties
index a53a6d0..78fba0f 100644
--- a/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/system.properties
+++ b/karaf/gshell/gshell-admin/src/main/resources/org/apache/felix/karaf/gshell/admin/etc/system.properties
@@ -18,4 +18,4 @@
 ################################################################################
 
 org.ops4j.pax.logging.DefaultServiceLog.level=ERROR
-servicemix.name=${servicemix.name}
+karaf.name=${karaf.name}
diff --git a/karaf/gshell/gshell-core/src/main/java/org/apache/felix/karaf/gshell/core/commands/InfoAction.java b/karaf/gshell/gshell-core/src/main/java/org/apache/felix/karaf/gshell/core/commands/InfoAction.java
index 600a369..b9ace8d 100644
--- a/karaf/gshell/gshell-core/src/main/java/org/apache/felix/karaf/gshell/core/commands/InfoAction.java
+++ b/karaf/gshell/gshell-core/src/main/java/org/apache/felix/karaf/gshell/core/commands/InfoAction.java
@@ -68,8 +68,8 @@
         //
         maxNameLen = 25;
         io.out.println("ServiceMix");
-        printValue("ServiceMix home", maxNameLen, System.getProperty("servicemix.home"));
-        printValue("ServiceMix base", maxNameLen, System.getProperty("servicemix.base"));
+        printValue("ServiceMix home", maxNameLen, System.getProperty("karaf.home"));
+        printValue("ServiceMix base", maxNameLen, System.getProperty("karaf.base"));
         printValue("ServiceMix Kernel version", maxNameLen, branding.getParent().getVersion());
 
         if (branding.getApplicationName() != null && branding.getApplicationVersion() != null) {
diff --git a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-local.xml b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-local.xml
index 54abea9..b6bcfcf 100644
--- a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-local.xml
+++ b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-local.xml
@@ -40,7 +40,7 @@
     </bean>
 
     <bean id="localConsole" class="org.apache.felix.karaf.gshell.core.LocalConsole">
-        <property name="createLocalShell" value="${servicemix.startLocalConsole}"/>
+        <property name="createLocalShell" value="${karaf.startLocalConsole}"/>
         <property name="shell" ref="localShell"/>
     </bean>
 
diff --git a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-osgi.xml b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-osgi.xml
index 292b1c9..8072080 100644
--- a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-osgi.xml
+++ b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-osgi.xml
@@ -68,7 +68,7 @@
     <osgix:cm-properties id="cmProps" persistent-id="org.apache.servicemix.shell">
         <prop key="sshPort">8101</prop>
         <prop key="sshRealm">servicemix</prop>
-        <prop key="hostKey">${servicemix.base}/etc/host.key</prop>
+        <prop key="hostKey">${karaf.base}/etc/host.key</prop>
     </osgix:cm-properties>
 
     <ctx:property-placeholder properties-ref="cmProps" />
diff --git a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-remote.xml b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-remote.xml
index 76a989a..81b5990 100644
--- a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-remote.xml
+++ b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell-remote.xml
@@ -79,7 +79,7 @@
 
     <bean id="sshServerFactory" class="org.apache.felix.karaf.gshell.core.sshd.SshServerFactory" init-method="start" destroy-method="stop">
         <constructor-arg ref="sshServer" />
-        <property name="start" value="${servicemix.startRemoteShell}" />
+        <property name="start" value="${karaf.startRemoteShell}" />
     </bean>
 
     <!--
diff --git a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell.xml b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell.xml
index df0651b..ed26b9b 100644
--- a/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell.xml
+++ b/karaf/gshell/gshell-core/src/main/resources/META-INF/spring/gshell.xml
@@ -42,7 +42,7 @@
     </bean>
 
     <bean id="application" class="org.apache.felix.karaf.gshell.core.ApplicationImpl">
-        <property name="id" value="${servicemix.name}"/>
+        <property name="id" value="${karaf.name}"/>
         <property name="io" ref="io"/>
         <property name="model">
             <bean class="org.apache.geronimo.gshell.application.model.ApplicationModel">
diff --git a/karaf/gshell/gshell-core/src/test/java/org/apache/felix/karaf/gshell/core/Test.java b/karaf/gshell/gshell-core/src/test/java/org/apache/felix/karaf/gshell/core/Test.java
index 3043692..ed1f4a9 100644
--- a/karaf/gshell/gshell-core/src/test/java/org/apache/felix/karaf/gshell/core/Test.java
+++ b/karaf/gshell/gshell-core/src/test/java/org/apache/felix/karaf/gshell/core/Test.java
@@ -25,7 +25,7 @@
 
     public void test() throws Exception {
         System.setProperty("startLocalConsole", "true");
-        System.setProperty("servicemix.name", "root");
+        System.setProperty("karaf.name", "root");
 
         ClassPathXmlApplicationContext context = null;
         try {
@@ -48,7 +48,7 @@
 
     public void testBanner() throws Exception {
         System.setProperty("startLocalConsole", "true");
-        System.setProperty("servicemix.name", "root");
+        System.setProperty("karaf.name", "root");
 
         ClassPathXmlApplicationContext context = null;
         try {
@@ -74,7 +74,7 @@
 
     public void testLs() throws Exception {
         System.setProperty("startLocalConsole", "true");
-        System.setProperty("servicemix.name", "root");
+        System.setProperty("karaf.name", "root");
 
         ClassPathXmlApplicationContext context = null;
         try {
@@ -100,7 +100,7 @@
 
     public void testCommandGroups() throws Exception {
         System.setProperty("startLocalConsole", "true");
-        System.setProperty("servicemix.name", "root");
+        System.setProperty("karaf.name", "root");
 
         ClassPathXmlApplicationContext context = null;
         try {
@@ -129,7 +129,7 @@
 
     public void testFileAccessCommands() throws Exception {
         System.setProperty("startLocalConsole", "true");
-        System.setProperty("servicemix.name", "root");
+        System.setProperty("karaf.name", "root");
 
         ClassPathXmlApplicationContext context = null;
         try {
diff --git a/karaf/gshell/gshell-core/src/test/resources/log4j.properties b/karaf/gshell/gshell-core/src/test/resources/log4j.properties
index 8cc85f8..0ca7b6a 100644
--- a/karaf/gshell/gshell-core/src/test/resources/log4j.properties
+++ b/karaf/gshell/gshell-core/src/test/resources/log4j.properties
@@ -29,5 +29,5 @@
 log4j.appender.out=org.apache.log4j.FileAppender
 log4j.appender.out.layout=org.apache.log4j.PatternLayout
 log4j.appender.out.layout.ConversionPattern=%d{ABSOLUTE} | %-5.5p | %-16.16t | %-32.32c{1} | %-32.32C %4L | %m%n
-log4j.appender.out.file=${servicemix.base}/data/log/servicemix.log
+log4j.appender.out.file=${karaf.base}/data/log/karaf.log
 log4j.appender.out.append=true
diff --git a/karaf/gshell/gshell-features/src/main/resources/META-INF/spring/gshell-features.xml b/karaf/gshell/gshell-features/src/main/resources/META-INF/spring/gshell-features.xml
index 271624a..c995a48 100644
--- a/karaf/gshell/gshell-features/src/main/resources/META-INF/spring/gshell-features.xml
+++ b/karaf/gshell/gshell-features/src/main/resources/META-INF/spring/gshell-features.xml
@@ -41,7 +41,7 @@
     <import resource="classpath:org/apache/felix/karaf/gshell/core/commands.xml" />
     
     <bean id="placeholderConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
-      <property name="location" value="file:${servicemix.home}/etc/org.apache.servicemix.features.cfg"/>
+      <property name="location" value="file:${karaf.home}/etc/org.apache.servicemix.features.cfg"/>
     </bean>
 
     <gshell:command-bundle>
diff --git a/karaf/gshell/gshell-wrapper/src/main/java/org/apache/felix/karaf/gshell/wrapper/InstallCommand.java b/karaf/gshell/gshell-wrapper/src/main/java/org/apache/felix/karaf/gshell/wrapper/InstallCommand.java
index 2d8ec42..9e4f365 100644
--- a/karaf/gshell/gshell-wrapper/src/main/java/org/apache/felix/karaf/gshell/wrapper/InstallCommand.java
+++ b/karaf/gshell/gshell-wrapper/src/main/java/org/apache/felix/karaf/gshell/wrapper/InstallCommand.java
@@ -51,14 +51,14 @@
     	
     	try {
     		String name = getName();    		
-    		File base = new File(System.getProperty("servicemix.base"));
+    		File base = new File(System.getProperty("karaf.base"));
     		File bin = new File(base, "bin");
     		File etc = new File(base, "etc");
     		File lib = new File(base, "lib");
     		
 			HashMap<String, String> props = new HashMap<String, String>();
-			props.put("${servicemix.home}", System.getProperty("servicemix.home"));
-			props.put("${servicemix.base}", base.getPath());
+			props.put("${karaf.home}", System.getProperty("karaf.home"));
+			props.put("${karaf.base}", base.getPath());
 			props.put("${name}", name);
 			props.put("${displayName}", getDisplayName());
 			props.put("${description}", getDescription());
@@ -321,7 +321,7 @@
 
 	public String getName() {
 		if( name ==  null ) {
-    		File base = new File(System.getProperty("servicemix.base"));
+    		File base = new File(System.getProperty("karaf.base"));
     		name = base.getName();
 		}
 		return name;
diff --git a/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/servicemix-service b/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/karaf-service
similarity index 98%
rename from karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/servicemix-service
rename to karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/karaf-service
index d80c13b..4fbfbe8 100755
--- a/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/servicemix-service
+++ b/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/unix/karaf-service
@@ -22,15 +22,15 @@
 APP_LONG_NAME="${displayName}"
 
 # Wrapper
-WRAPPER_CMD="${servicemix.base}/bin/${APP_NAME}-wrapper"
-WRAPPER_CONF="${servicemix.base}/etc/${APP_NAME}-wrapper.conf"
+WRAPPER_CMD="${karaf.base}/bin/${APP_NAME}-wrapper"
+WRAPPER_CONF="${karaf.base}/etc/${APP_NAME}-wrapper.conf"
 
 # Priority at which to run the wrapper.  See "man nice" for valid priorities.
 #  nice is only used if a priority is specified.
 PRIORITY=
 
 # Location of the pid file.
-PIDDIR="${servicemix.base}/data"
+PIDDIR="${karaf.base}/data"
 
 # If uncommented, causes the Wrapper to be shutdown using an anchor file.
 #  When launched with the 'start' command, it will also ignore all INT and
diff --git a/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/servicemix-service.bat b/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/karaf-service.bat
similarity index 95%
rename from karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/servicemix-service.bat
rename to karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/karaf-service.bat
index df0160e..f29dccd 100644
--- a/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/servicemix-service.bat
+++ b/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/karaf-service.bat
@@ -21,13 +21,13 @@
 
 set APP_NAME=${name}
 set APP_LONG_NAME=${displayName}
-set APP_BASE=${servicemix.base}
+set APP_BASE=${karaf.base}
 
 if ""%1"" == ""run"" goto doRun
 if ""%1"" == ""install"" goto doInstall
 if ""%1"" == ""remove"" goto doRemove
 
-echo Usage:  servicemix-service ( commands ... )
+echo Usage:  karaf-service ( commands ... )
 echo commands:
 echo   run               Start %APP_NAME% in the current console
 echo   install           Install %APP_NAME% as a Windows service
diff --git a/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/servicemix-wrapper.exe b/karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/karaf-wrapper.exe
similarity index 100%
rename from karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/servicemix-wrapper.exe
rename to karaf/gshell/gshell-wrapper/src/main/resources/org/apache/felix/karaf/gshell/wrapper/windows/karaf-wrapper.exe
Binary files differ
diff --git a/karaf/itests/src/test/java/org/apache/felix/karaf/gshell/itests/AbstractIntegrationTest.java b/karaf/itests/src/test/java/org/apache/felix/karaf/gshell/itests/AbstractIntegrationTest.java
index 5f7ca48..74e731a 100644
--- a/karaf/itests/src/test/java/org/apache/felix/karaf/gshell/itests/AbstractIntegrationTest.java
+++ b/karaf/itests/src/test/java/org/apache/felix/karaf/gshell/itests/AbstractIntegrationTest.java
@@ -114,10 +114,10 @@
 
             // this is how you set the default log level when using pax logging (logProfile)
             systemProperty("org.ops4j.pax.logging.DefaultServiceLog.level").value("INFO"),
-            systemProperty("servicemix.name").value("root"),
-            systemProperty("servicemix.base").value("target/smx.base"),
-            systemProperty("servicemix.startLocalConsole").value("false"),
-            systemProperty("servicemix.startRemoteShell").value("false"),
+            systemProperty("karaf.name").value("root"),
+            systemProperty("karaf.base").value("target/smx.base"),
+            systemProperty("karaf.startLocalConsole").value("false"),
+            systemProperty("karaf.startRemoteShell").value("false"),
 
             // hack system packages
             systemPackages("org.apache.felix.karaf.main.spi;version=1.0.0", "org.apache.felix.karaf.jaas.boot"),
diff --git a/karaf/itests/src/test/resources/log4j.properties b/karaf/itests/src/test/resources/log4j.properties
index 8cc85f8..0ca7b6a 100644
--- a/karaf/itests/src/test/resources/log4j.properties
+++ b/karaf/itests/src/test/resources/log4j.properties
@@ -29,5 +29,5 @@
 log4j.appender.out=org.apache.log4j.FileAppender
 log4j.appender.out.layout=org.apache.log4j.PatternLayout
 log4j.appender.out.layout.ConversionPattern=%d{ABSOLUTE} | %-5.5p | %-16.16t | %-32.32c{1} | %-32.32C %4L | %m%n
-log4j.appender.out.file=${servicemix.base}/data/log/servicemix.log
+log4j.appender.out.file=${karaf.base}/data/log/karaf.log
 log4j.appender.out.append=true
diff --git a/karaf/jaas/jaas-modules/src/main/resources/META-INF/spring/servicemix-jaas-module.xml b/karaf/jaas/jaas-modules/src/main/resources/META-INF/spring/servicemix-jaas-module.xml
index 8187e2b..2a5ad64 100644
--- a/karaf/jaas/jaas-modules/src/main/resources/META-INF/spring/servicemix-jaas-module.xml
+++ b/karaf/jaas/jaas-modules/src/main/resources/META-INF/spring/servicemix-jaas-module.xml
@@ -48,12 +48,12 @@
     </jaas:config>
     -->
 
-    <!-- Bean to allow the ${servicemix.home} property to be correctly resolved -->
+    <!-- Bean to allow the ${karaf.home} property to be correctly resolved -->
     <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" />
 
     <jaas:config id="servicemix">
         <jaas:module className="org.apache.felix.karaf.jaas.modules.properties.PropertiesLoginModule" flags="required">
-            users = ${servicemix.base}/etc/users.properties
+            users = ${karaf.base}/etc/users.properties
         </jaas:module>
     </jaas:config>
 
diff --git a/karaf/main/src/main/java/org/apache/felix/karaf/main/DefaultJDBCLock.java b/karaf/main/src/main/java/org/apache/felix/karaf/main/DefaultJDBCLock.java
index adc1975..3b29729 100644
--- a/karaf/main/src/main/java/org/apache/felix/karaf/main/DefaultJDBCLock.java
+++ b/karaf/main/src/main/java/org/apache/felix/karaf/main/DefaultJDBCLock.java
@@ -33,13 +33,13 @@
  */
 public class DefaultJDBCLock implements Lock {
 
-    private static final String PROPERTY_LOCK_URL               = "servicemix.lock.jdbc.url";
-    private static final String PROPERTY_LOCK_JDBC_DRIVER       = "servicemix.lock.jdbc.driver";
-    private static final String PROPERTY_LOCK_JDBC_USER         = "servicemix.lock.jdbc.user";
-    private static final String PROPERTY_LOCK_JDBC_PASSWORD     = "servicemix.lock.jdbc.password";
-    private static final String PROPERTY_LOCK_JDBC_TABLE        = "servicemix.lock.jdbc.table";
-    private static final String PROPERTY_LOCK_JDBC_CLUSTERNAME  = "servicemix.lock.jdbc.clustername";
-    private static final String PROPERTY_LOCK_JDBC_TIMEOUT      = "servicemix.lock.jdbc.timeout";
+    private static final String PROPERTY_LOCK_URL               = "karaf.lock.jdbc.url";
+    private static final String PROPERTY_LOCK_JDBC_DRIVER       = "karaf.lock.jdbc.driver";
+    private static final String PROPERTY_LOCK_JDBC_USER         = "karaf.lock.jdbc.user";
+    private static final String PROPERTY_LOCK_JDBC_PASSWORD     = "karaf.lock.jdbc.password";
+    private static final String PROPERTY_LOCK_JDBC_TABLE        = "karaf.lock.jdbc.table";
+    private static final String PROPERTY_LOCK_JDBC_CLUSTERNAME  = "karaf.lock.jdbc.clustername";
+    private static final String PROPERTY_LOCK_JDBC_TIMEOUT      = "karaf.lock.jdbc.timeout";
 
     private final Statements statements;
     private Connection lockConnection;
diff --git a/karaf/main/src/main/java/org/apache/felix/karaf/main/Main.java b/karaf/main/src/main/java/org/apache/felix/karaf/main/Main.java
index daa18a0..1eec5aa 100644
--- a/karaf/main/src/main/java/org/apache/felix/karaf/main/Main.java
+++ b/karaf/main/src/main/java/org/apache/felix/karaf/main/Main.java
@@ -87,22 +87,22 @@
      * The system property for specifying the ServiceMix home directory.  The home directory
      * hold the binary install of ServiceMix.
      */
-    public static final String PROP_SERVICEMIX_HOME = "servicemix.home";
+    public static final String PROP_KARAF_HOME = "karaf.home";
     /**
      * The environment variable for specifying the ServiceMix home directory.  The home directory
      * hold the binary install of ServiceMix.
      */
-    public static final String ENV_SERVICEMIX_HOME = "SERVICEMIX_HOME";
+    public static final String ENV_KARAF_HOME = "KARAF_HOME";
     /**
      * The system property for specifying the ServiceMix base directory.  The base directory
      * holds the configuration and data for a ServiceMix instance.
      */
-    public static final String PROP_SERVICEMIX_BASE = "servicemix.base";
+    public static final String PROP_KARAF_BASE = "karaf.base";
     /**
      * The environment variable for specifying the ServiceMix base directory.  The base directory
      * holds the configuration and data for a ServiceMix instance.
      */
-    public static final String ENV_SERVICEMIX_BASE = "SERVICEMIX_BASE";
+    public static final String ENV_KARAF_BASE = "KARAF_BASE";
 
     /**
      * Config property which identifies directories which contain bundles to be loaded by SMX
@@ -112,21 +112,21 @@
     /**
      * Config property that indicates we want to convert bundles locations to maven style urls
      */
-    public static final String PROPERTY_CONVERT_TO_MAVEN_URL = "servicemix.maven.convert";
+    public static final String PROPERTY_CONVERT_TO_MAVEN_URL = "karaf.maven.convert";
 
     /**
      * If a lock should be used before starting the runtime
      */
-    public static final String PROPERTY_USE_LOCK = "servicemix.lock";
+    public static final String PROPERTY_USE_LOCK = "karaf.lock";
 
     /**
      * The lock implementation
      */
-    public static final String PROPERTY_LOCK_CLASS = "servicemix.lock.class";
+    public static final String PROPERTY_LOCK_CLASS = "karaf.lock.class";
 
-    public static final String PROPERTY_LOCK_DELAY = "servicemix.lock.delay";
+    public static final String PROPERTY_LOCK_DELAY = "karaf.lock.delay";
 
-    public static final String PROPERTY_LOCK_LEVEL = "servicemix.lock.level";
+    public static final String PROPERTY_LOCK_LEVEL = "karaf.lock.level";
 
     public static final String PROPERTY_LOCK_CLASS_DEFAULT = SimpleFileLock.class.getName();
 
@@ -155,8 +155,8 @@
         //System.out.println("ServiceMix Home: "+main.servicemixHome.getPath());
         //System.out.println("ServiceMix Base: "+main.servicemixBase.getPath());
 
-        System.setProperty(PROP_SERVICEMIX_HOME, servicemixHome.getPath());
-        System.setProperty(PROP_SERVICEMIX_BASE, servicemixBase.getPath());
+        System.setProperty(PROP_KARAF_HOME, servicemixHome.getPath());
+        System.setProperty(PROP_KARAF_BASE, servicemixBase.getPath());
 
         // Load system properties.
         loadSystemProperties();
@@ -341,15 +341,15 @@
         File rc = null;
 
         // Use the system property if specified.
-        String path = System.getProperty(PROP_SERVICEMIX_HOME);
+        String path = System.getProperty(PROP_KARAF_HOME);
         if (path != null) {
-            rc = validateDirectoryExists(path, "Invalid " + PROP_SERVICEMIX_HOME + " system property");
+            rc = validateDirectoryExists(path, "Invalid " + PROP_KARAF_HOME + " system property");
         }
 
         if (rc == null) {
-            path = System.getenv(ENV_SERVICEMIX_HOME);
+            path = System.getenv(ENV_KARAF_HOME);
             if (path != null) {
-                rc = validateDirectoryExists(path, "Invalid " + ENV_SERVICEMIX_HOME + " environment variable");
+                rc = validateDirectoryExists(path, "Invalid " + ENV_KARAF_HOME + " environment variable");
             }
         }
 
@@ -378,7 +378,7 @@
             }
         }
         if (rc == null) {
-            throw new IOException("The ServiceMix install directory could not be determined.  Please set the " + PROP_SERVICEMIX_HOME + " system property or the " + ENV_SERVICEMIX_HOME + " environment variable.");
+            throw new IOException("The ServiceMix install directory could not be determined.  Please set the " + PROP_KARAF_HOME + " system property or the " + ENV_KARAF_HOME + " environment variable.");
         }
 
         return rc;
@@ -403,15 +403,15 @@
     private static File getServiceMixBase(File defaultValue) {
         File rc = null;
 
-        String path = System.getProperty(PROP_SERVICEMIX_BASE);
+        String path = System.getProperty(PROP_KARAF_BASE);
         if (path != null) {
-            rc = validateDirectoryExists(path, "Invalid " + PROP_SERVICEMIX_BASE + " system property");
+            rc = validateDirectoryExists(path, "Invalid " + PROP_KARAF_BASE + " system property");
         }
 
         if (rc == null) {
-            path = System.getenv(ENV_SERVICEMIX_BASE);
+            path = System.getenv(ENV_KARAF_BASE);
             if (path != null) {
-                rc = validateDirectoryExists(path, "Invalid " + ENV_SERVICEMIX_BASE + " environment variable");
+                rc = validateDirectoryExists(path, "Invalid " + ENV_KARAF_BASE + " environment variable");
             }
         }
 
diff --git a/karaf/main/src/main/java/org/apache/felix/karaf/main/SimpleFileLock.java b/karaf/main/src/main/java/org/apache/felix/karaf/main/SimpleFileLock.java
index b79c1c1..110058f 100644
--- a/karaf/main/src/main/java/org/apache/felix/karaf/main/SimpleFileLock.java
+++ b/karaf/main/src/main/java/org/apache/felix/karaf/main/SimpleFileLock.java
@@ -26,8 +26,8 @@
 
 public class SimpleFileLock implements Lock {
 
-    private static final String PROPERTY_LOCK_DIR = "servicemix.lock.dir";
-    private static final String PROP_SERVICEMIX_BASE = "servicemix.base";
+    private static final String PROPERTY_LOCK_DIR = "karaf.lock.dir";
+    private static final String PROP_KARAF_BASE = "karaf.base";
     private RandomAccessFile lockFile;
     private FileLock lock;
 
@@ -39,7 +39,7 @@
                 File servicemixLock = getServiceMixLock(new File(lock), props);
                 props.setProperty(PROPERTY_LOCK_DIR, servicemixLock.getPath());
             } else {
-                props.setProperty(PROPERTY_LOCK_DIR, System.getProperty(PROP_SERVICEMIX_BASE));
+                props.setProperty(PROPERTY_LOCK_DIR, System.getProperty(PROP_KARAF_BASE));
             }
 
             File base = new File(props.getProperty(PROPERTY_LOCK_DIR));
@@ -77,9 +77,9 @@
         }
 
         if (rc == null) {
-            path = props.getProperty(PROP_SERVICEMIX_BASE);
+            path = props.getProperty(PROP_KARAF_BASE);
             if (path != null) {
-                rc = validateDirectoryExists(path, "Invalid " + PROP_SERVICEMIX_BASE + " property");
+                rc = validateDirectoryExists(path, "Invalid " + PROP_KARAF_BASE + " property");
             }
         }
 
