diff --git a/ipojo/core/pom.xml b/ipojo/core/pom.xml
index 8debd71..d5044a0 100644
--- a/ipojo/core/pom.xml
+++ b/ipojo/core/pom.xml
@@ -6,9 +6,9 @@
 	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
@@ -29,11 +29,11 @@
 	<artifactId>org.apache.felix.ipojo</artifactId>
 	<groupId>org.apache.felix</groupId>
 	<version>1.3.0-SNAPSHOT</version>
-	
+
 	<properties>
-		<ipojo.package.version>1.3.0</ipojo.package.version>
+		<ipojo.package.version>1.4.0</ipojo.package.version>
 	</properties>
-	
+
 	<dependencies>
 		<dependency>
 			<groupId>org.apache.felix</groupId>
@@ -48,7 +48,7 @@
 		<dependency>
 			<groupId>org.apache.felix</groupId>
 			<artifactId>org.apache.felix.ipojo.metadata</artifactId>
-			<version>1.3.0-SNAPSHOT</version>
+			<version>${pom.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>asm</groupId>
@@ -75,28 +75,28 @@
 						<Bundle-Vendor> The Apache Software Foundation </Bundle-Vendor>
 						<Bundle-SymbolicName>org.apache.felix.ipojo;singleton:=true</Bundle-SymbolicName>
 						<Bundle-Description> iPOJO Core Framework </Bundle-Description>
-						<Bundle-Activator> org.apache.felix.ipojo.Extender 
+						<Bundle-Activator> org.apache.felix.ipojo.Extender
 						</Bundle-Activator>
 						<Bundle-DocURL>
-							http://felix.apache.org/site/apache-felix-ipojo.html 
+							http://felix.apache.org/site/apache-felix-ipojo.html
 						</Bundle-DocURL>
 						<IPOJO-Extension>
 							component:org.apache.felix.ipojo.ComponentFactory,
-							handler:org.apache.felix.ipojo.HandlerManagerFactory 
+							handler:org.apache.felix.ipojo.HandlerManagerFactory
 						</IPOJO-Extension>
-						<Import-Package> 
-							org.osgi.framework;version=1.3, <!-- To support KF 2 --> 
+						<Import-Package>
+							org.osgi.framework;version=1.3, <!-- To support KF 2 -->
 							org.osgi.service.cm,
-							org.osgi.service.log, 
+							org.osgi.service.log,
 							!net.sourceforge.cobertura.* <!--  To support code coverage -->
 						</Import-Package>
-						<Private-Package> 
+						<Private-Package>
 							org.apache.felix.ipojo.handlers.architecture,
 							org.apache.felix.ipojo.handlers.lifecycle.callback,
 							org.apache.felix.ipojo.handlers.lifecycle.controller,
 							org.objectweb.asm
 						</Private-Package>
-						<Export-Package> 
+						<Export-Package>
 							org.apache.felix.ipojo; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.metadata; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.architecture; version="${ipojo.package.version}",
@@ -106,12 +106,12 @@
 							org.apache.felix.ipojo.handlers.providedservice; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.handlers.configuration; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.context; version="${ipojo.package.version}",
-							org.osgi.service.cm, 
-							org.osgi.service.log 
+							org.osgi.service.cm,
+							org.osgi.service.log
 						</Export-Package>
-						<Include-Resource> 
+						<Include-Resource>
 							META-INF/LICENCE=LICENSE,
-							META-INF/NOTICE=NOTICE 
+							META-INF/NOTICE=NOTICE
 						</Include-Resource>
 						<_donotcopy> (CVS|.svn|.+.bak|~.+|metadata.xml) </_donotcopy>
 					</instructions>
@@ -120,7 +120,7 @@
 			<plugin>
 				<groupId>org.apache.felix</groupId>
 				<artifactId>maven-ipojo-plugin</artifactId>
-				<version>1.3.0-SNAPSHOT</version>
+				<version>${pom.version}</version>
 				<executions>
 					<execution>
 						<goals>
