diff --git a/hivesterix/pom.xml b/hivesterix/pom.xml
index 60c4736..66e45d6 100644
--- a/hivesterix/pom.xml
+++ b/hivesterix/pom.xml
@@ -17,7 +17,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>edu.uci.ics.hyracks</groupId>
 	<artifactId>hivesterix</artifactId>
-	<version>0.2.9-SNAPSHOT</version>
+	<version>0.2.9</version>
 	<packaging>pom</packaging>
 	<name>hivesterix</name>
 
