diff --git a/HGamer3D-Data.cabal b/HGamer3D-Data.cabal
--- a/HGamer3D-Data.cabal
+++ b/HGamer3D-Data.cabal
@@ -1,6 +1,6 @@
 Name:                HGamer3D-Data
-Version:             0.1.3
-Synopsis:            Library to enable 3D game development for Haskell - API
+Version:             0.1.4
+Synopsis:            Library to enable 3D game development for Haskell - Data
 Description:         
 	Library, to enable 3D game development for Haskell,
 	based on bindings to 3D Graphics, pyhsics engine and additional libraries.
@@ -23,9 +23,9 @@
 Extra-source-files:  Setup.hs 
 
 Library
-  Build-Depends:     base >= 3 && < 5
+  Build-Depends:     base >= 3 && < 5, Vec == 0.9.7, Vec-Transform == 1.0.4
 
-  Exposed-modules:   HGamer3D.Data.Vector2,HGamer3D.Data.Vector3,HGamer3D.Data.Vector4,HGamer3D.Data.ColourValue,HGamer3D.Data.Quaternion,HGamer3D.Data.HG3DClass,HGamer3D.Data.Radian,HGamer3D.Data.Degree,HGamer3D.Data.Angle
+  Exposed-modules:   HGamer3D.Data.Vector2,HGamer3D.Data.Vector3,HGamer3D.Data.Vector4,HGamer3D.Data.Matrix4,HGamer3D.Data.Colour,HGamer3D.Data.Quaternion,HGamer3D.Data.HG3DClass,HGamer3D.Data.Angle
   Other-modules:     
 
   c-sources:         
diff --git a/HGamer3D/Data/Angle.hs b/HGamer3D/Data/Angle.hs
--- a/HGamer3D/Data/Angle.hs
+++ b/HGamer3D/Data/Angle.hs
@@ -18,20 +18,65 @@
 
 -- Angle.hs
 
+{- |
+	Angles as Degrees or Radians, based on Float datatype
+	copied and changed to float from AC-Angle packet
+-}
+
 module HGamer3D.Data.Angle 
 
 (
-	-- export Angle Type again
-	Angle (Angle),
+	-- export Radians and Degrees 
+	Radians (Radians),
+	Degrees (Degrees),
+	degrees,
+	radians
 	
-	-- export all functions
+	-- instances are automatically exported
+	-- Angle, sine, cosine, tangent, arcsine, arccosine, arctangent
 	
 )
 
 where
 
-data Angle = Angle {
-  aA :: Float
-   } deriving (Eq, Show)
+-- | An angle in radians.
+data Radians = Radians Float deriving (Eq, Ord, Show)
 
+-- | An angle in degrees.
+data Degrees = Degrees Float deriving (Eq, Ord, Show)
 
+-- | Convert from radians to degrees.
+degrees :: Radians -> Degrees
+degrees (Radians x) = Degrees (x/pi*180)
+
+-- | Convert from degrees to radians.
+radians :: Degrees -> Radians
+radians (Degrees x) = Radians (x/180*pi)
+
+-- | Type-class for angles.
+class Angle a where
+  sine    :: a -> Float
+  cosine  :: a -> Float
+  tangent :: a -> Float
+
+  arcsine    :: Float -> a
+  arccosine  :: Float -> a
+  arctangent :: Float -> a
+
+instance Angle Radians where
+  sine    (Radians x) = sin x
+  cosine  (Radians x) = cos x
+  tangent (Radians x) = tan x
+
+  arcsine    x = Radians (asin x)
+  arccosine  x = Radians (acos x)
+  arctangent x = Radians (atan x)
+
+instance Angle Degrees where
+  sine    =    sine . radians
+  cosine  =  cosine . radians
+  tangent = tangent . radians
+
+  arcsine    = degrees . arcsine
+  arccosine  = degrees . arccosine
+  arctangent = degrees . arctangent
diff --git a/HGamer3D/Data/Colour.hs b/HGamer3D/Data/Colour.hs
new file mode 100644
--- /dev/null
+++ b/HGamer3D/Data/Colour.hs
@@ -0,0 +1,38 @@
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- Copyright 2011 Dr. Peter Althainz
+--
+-- Licensed 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.
+
+-- ColourValue.hs
+
+module HGamer3D.Data.Colour 
+
+(
+	-- export Colour Type again
+	Colour (Colour, cRed, cGreen, cBlue, cAlpha),
+	
+	-- export all functions
+	
+)
+
+where
+data Colour = Colour {
+  cRed :: Float,
+  cGreen :: Float,
+  cBlue :: Float,
+  cAlpha :: Float
+   } deriving (Eq, Show)
+
diff --git a/HGamer3D/Data/ColourValue.hs b/HGamer3D/Data/ColourValue.hs
deleted file mode 100644
--- a/HGamer3D/Data/ColourValue.hs
+++ /dev/null
@@ -1,38 +0,0 @@
--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- Copyright 2011 Dr. Peter Althainz
---
--- Licensed 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.
-
--- ColourValue.hs
-
-module HGamer3D.Data.ColourValue 
-
-(
-	-- export ColourValue Type again
-	ColourValue (ColourValue),
-	
-	-- export all functions
-	
-)
-
-where
-data ColourValue = ColourValue {
-  cvR :: Float,
-  cvG :: Float,
-  cvB :: Float,
-  cvA :: Float
-   } deriving (Eq, Show)
-
diff --git a/HGamer3D/Data/Degree.hs b/HGamer3D/Data/Degree.hs
deleted file mode 100644
--- a/HGamer3D/Data/Degree.hs
+++ /dev/null
@@ -1,36 +0,0 @@
--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- Copyright 2011 Dr. Peter Althainz
---
--- Licensed 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.
-
--- Degree.hs
-
-module HGamer3D.Data.Degree 
-
-(
-	-- export Degree Type again
-	Degree (Degree),
-	
-	-- export all functions
-	
-)
-
-where
-
-
-data Degree = Degree {
-  dD :: Float
-   } deriving (Eq, Show)
diff --git a/HGamer3D/Data/Matrix4.hs b/HGamer3D/Data/Matrix4.hs
new file mode 100644
--- /dev/null
+++ b/HGamer3D/Data/Matrix4.hs
@@ -0,0 +1,115 @@
+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- Copyright 2012 Dr. Peter Althainz
+--
+-- Licensed 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.
+
+-- Matrix4.hs, the 4x4 matrix type 
+
+module HGamer3D.Data.Matrix4 
+
+(
+	Matrix4,
+	HGamer3D.Data.Matrix4.matToLists,
+	HGamer3D.Data.Matrix4.matFromLists,
+	extendV3,
+	oneV3,
+	zeroV3,
+	toV3,
+	HGamer3D.Data.Matrix4.multvm,
+	HGamer3D.Data.Matrix4.multmv,
+	HGamer3D.Data.Matrix4.multmm,
+	HGamer3D.Data.Matrix4.transpose,
+	
+	HGamer3D.Data.Matrix4.translation,
+	HGamer3D.Data.Matrix4.rotationX,
+	HGamer3D.Data.Matrix4.rotationY,
+	HGamer3D.Data.Matrix4.rotationZ,
+	HGamer3D.Data.Matrix4.rotationVec,
+	HGamer3D.Data.Matrix4.rotationEuler,
+	HGamer3D.Data.Matrix4.rotationQuat
+)
+
+where
+
+import Data.Vec.Base
+import Data.Vec.Nat
+import Data.Vec.Packed
+import Data.Vec.LinAlg
+import Data.Vec.LinAlg.Transform3D
+import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4
+import HGamer3D.Data.Quaternion
+
+newtype Matrix4 = Matrix4 (Mat44 Float)
+
+matToLists :: Matrix4 -> [[Float]]
+matToLists (Matrix4 mat) = Data.Vec.Base.matToLists mat
+
+matFromLists :: [[Float]] -> Matrix4
+matFromLists lists = Matrix4 $ Data.Vec.Base.matFromLists lists
+
+extendV3 :: Vector3 -> Float -> Vector4
+extendV3 v3 f = vector4 (v3X v3) (v3X v3) (v3Z v3) f
+
+oneV3 :: Vector3 -> Vector4
+oneV3 v3 = extendV3 v3 1.0
+
+zeroV3 :: Vector3 -> Vector4
+zeroV3 v3 = extendV3 v3 0.0
+
+toV3 :: Vector4 -> Vector3
+toV3 v4 = vector3 (v4X v4) (v4Y v4) (v4Z v4)
+
+multvm :: Vector4 -> Matrix4 -> Vector4
+multvm (Vector4 v) (Matrix4 m) = Vector4 $ pack (Data.Vec.LinAlg.multvm (unpack v) m)
+
+multmv :: Matrix4 -> Vector4 -> Vector4
+multmv (Matrix4 m) (Vector4 v) = Vector4 $ pack (Data.Vec.LinAlg.multmv m (unpack v))
+
+multmm :: Matrix4 -> Matrix4 -> Matrix4
+multmm (Matrix4 m1) (Matrix4 m2) = Matrix4 (Data.Vec.LinAlg.multmm m1 m2)
+
+transpose :: Matrix4 -> Matrix4
+transpose (Matrix4 m) = Matrix4 (Data.Vec.LinAlg.transpose m)
+
+translation :: Vector3 -> Matrix4
+translation (Vector3 v)  = Matrix4 (Data.Vec.LinAlg.Transform3D.translation (unpack v) )
+
+rotationX :: Float -> Matrix4
+rotationX f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationX f )
+
+rotationY :: Float -> Matrix4
+rotationY f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationY f )
+
+rotationZ :: Float -> Matrix4
+rotationZ f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationZ f )
+
+rotationVec :: Vector3 -> Float -> Matrix4
+rotationVec (Vector3 v) f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationVec (unpack v) f )
+
+rotationEuler :: Vector3 -> Matrix4
+rotationEuler (Vector3 v)  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationEuler (unpack v) )
+
+rotationQuat :: Quaternion -> Matrix4
+rotationQuat q = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationQuat v4 ) where
+	w = qW q
+	v = qV q
+	x = v3X v
+	y = v3Y v
+	z = v3Z v
+	v4 = x :. y :. z :. w :. ()
+
+
diff --git a/HGamer3D/Data/Quaternion.hs b/HGamer3D/Data/Quaternion.hs
--- a/HGamer3D/Data/Quaternion.hs
+++ b/HGamer3D/Data/Quaternion.hs
@@ -22,68 +22,66 @@
 
 (
 	-- export Quaternion Type again
-	Quaternion (Quaternion),
-	
-	-- export all functions
-	realQ,
-	imagQ,
-	fromScalarQ,
-	listFromQ,
-	fromListQ,
-	addQ,
-	subQ,
+	Quaternion (Quaternion, qW, qV),
+	quaternion,
 	mulQ,
-	normQ,
 	conjQ,
-	negQ,
-	fromRotationQ,
+	normQ,
+	normalizeQ,
+	dotQ,
+	rotateVQ,
+	fromRotationQ
 	
+	-- export all functions
 )
 
 where
 
 import HGamer3D.Data.Vector3
+import HGamer3D.Data.Vector4 (Vector4, vector4)
 
 data Quaternion = Quaternion {
-  qFW :: Float,
-  qFX :: Float,
-  qFY :: Float,
-  qFZ :: Float
-   } deriving (Eq, Show)
+  qW :: Float,
+  qV :: Vector3
+} deriving (Eq, Show)
 
-realQ :: Quaternion -> Float
-realQ (Quaternion r _ _ _) = r
- 
-imagQ :: Quaternion -> [Float]
-imagQ (Quaternion _ i j k) = [i, j, k]
- 
-fromScalarQ s = Quaternion s 0 0 0
- 
-listFromQ (Quaternion a b c d) = [a,b,c,d]
-fromListQ [a, b, c, d] = Quaternion a b c d
- 
-addQ, subQ, mulQ :: Quaternion -> Quaternion -> Quaternion
+quaternion w x y z = Quaternion w (vector3 x y z)
 
-addQ (Quaternion a b c d) (Quaternion p q r s) = Quaternion (a+p) (b+q) (c+r) (d+s)
- 
-subQ (Quaternion a b c d) (Quaternion p q r s) = Quaternion (a-p) (b-q) (c-r) (d-s)
- 
-mulQ (Quaternion a b c d) (Quaternion p q r s) =
-  Quaternion  (a*p - b*q - c*r - d*s)
-     (a*q + b*p + c*s - d*r)
-     (a*r - b*s + c*p + d*q)
-     (a*s + b*r - c*q + d*p)
+mulQ :: Quaternion -> Quaternion -> Quaternion
+mulQ q1 q2 = Quaternion ((w1 * w2) - (v1 `dotV3` v2)) ( (scaleV3 w1 v2) + (scaleV3 w2 v1) + (v1 `crossV3` v2) )  where
+	w1 = qW q1
+	w2 = qW q2
+	v1 = qV q1
+	v2 = qV q2 
 
+conjQ :: Quaternion -> Quaternion
+conjQ q = Quaternion (qW q) (scaleV3 (-1.0) (qV q)) 
+
 normQ :: Quaternion -> Float 
-normQ q  = sqrt $ sum $ zipWith (*) x x where x = listFromQ q
- 
-conjQ, negQ :: Quaternion -> Quaternion
+normQ q = sqrt $ dotQ q (conjQ q)
 
-conjQ (Quaternion a b c d) = Quaternion a (-b) (-c) (-d)
- 
-negQ (Quaternion a b c d) = Quaternion (-a) (-b) (-c) (-d)
+normalizeQ :: Quaternion -> Quaternion
+normalizeQ q = Quaternion ( (qW q) / n ) ( (scaleV3 (1/n)) (qV q) ) where
+	n = normQ q
 
+dotQ :: Quaternion -> Quaternion -> Float
+dotQ q1 q2 = (w1 * w2) + (v1 `dotV3` v2) where
+	w1 = qW q1
+	w2 = qW q2
+	v1 = qV q1
+	v2 = qV q2 
+ 
 fromRotationQ :: Float -> Vector3 -> Quaternion
-fromRotationQ a (Vector3 x y z) = Quaternion (cos h) (s*x) (s*y) (s*z) where
+fromRotationQ a v = Quaternion (cos h) (scaleV3 s v) where
 					h = a/2.0
 					s = sin h
+
+rotateVQ :: Vector3 -> Quaternion -> Vector3
+rotateVQ v q = qV (mulQ q (mulQ v' q')) where 
+	v' = Quaternion 0.0 v
+	q' = conjQ q
+
+toVector4 :: Quaternion -> Vector4
+toVector4 q = vector4 (v3X v) (v3Y v) (v3Z v) w where
+	v = qV q
+	w = qW q
diff --git a/HGamer3D/Data/Radian.hs b/HGamer3D/Data/Radian.hs
deleted file mode 100644
--- a/HGamer3D/Data/Radian.hs
+++ /dev/null
@@ -1,37 +0,0 @@
--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- Copyright 2011 Dr. Peter Althainz
---
--- Licensed 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.
-
--- Radian.hs
-
-module HGamer3D.Data.Radian 
-
-(
-	-- export Radian Type again
-	Radian (Radian),
-	
-	-- export all functions
-	
-)
-
-where
-
-data Radian = Radian {
-  rR :: Float
-   } deriving (Eq, Show)
-
-
diff --git a/HGamer3D/Data/Vector2.hs b/HGamer3D/Data/Vector2.hs
--- a/HGamer3D/Data/Vector2.hs
+++ b/HGamer3D/Data/Vector2.hs
@@ -21,17 +21,98 @@
 module HGamer3D.Data.Vector2 
 
 (
-	-- export Vector2 Type again
-	Vector2 (Vector2),
+	-- export Vector2 Type and its functions again
 	
-	-- export all functions
+	Vector2 (Vector2),
+	vector2,
+	uniV2,
+	v2X,v2Y,
+	HGamer3D.Data.Vector2.dotV2,
+	HGamer3D.Data.Vector2.normSqV2,
+	HGamer3D.Data.Vector2.normV2,
+	HGamer3D.Data.Vector2.normalizeV2,
+	HGamer3D.Data.Vector2.scaleV2
 	
 )
 
 where
 
-data Vector2 = Vector2 {
-  v2X :: Float,
-  v2Y :: Float
-   } deriving (Eq, Show)
+import Data.Vec.Base
+import Data.Vec.Nat
+import Data.Vec.Packed
+import Data.Vec.LinAlg
+
+newtype Vector2 = Vector2 Vec2F
+
+vector2 :: Float -> Float -> Vector2
+vector2 a b = Vector2 ( pack (a :. b :. ()) )
+
+uniV2 :: Float -> Vector2
+uniV2 f = Vector2 (pack (vec f))
+
+v2X :: Vector2 -> Float
+v2X (Vector2 v2) = get n0 v2
+
+v2Y :: Vector2 -> Float
+v2Y (Vector2 v2) = get n1 v2
+
+
+
+liftv :: (a -> Vec2F) -> (a -> Vector2)
+liftv f = f1 where
+	f1 a1 = (Vector2 (f a1)) 
+
+
+lift1 :: (Vec2F -> a) -> (Vector2 -> a)
+lift1 f = f1 where
+	f1 (Vector2 a1) = f a1 
+
+lift1v :: (Vec2F -> Vec2F) -> (Vector2 -> Vector2)
+lift1v f = f2 where
+	f2 a = (Vector2 (f1 a))
+	f1 (Vector2 a1) = f a1 
+
+lift2 :: (Vec2F -> Vec2F -> a) -> (Vector2 -> Vector2 -> a)
+lift2 f = f1 where
+	f1 (Vector2 a1) (Vector2 b1) = f a1 b1 
+
+lift2v :: (Vec2F -> Vec2F -> Vec2F) -> (Vector2 -> Vector2 -> Vector2)
+lift2v f = f2 where
+	f2 a b = (Vector2 (f1 a b))
+	f1 (Vector2 a1) (Vector2 b1) = f a1 b1 
+
+lift2vp :: (Vec2 Float -> Vec2 Float -> Vec2 Float) -> (Vector2 -> Vector2 -> Vector2)
+lift2vp f = f2 where
+	f2 a b = (Vector2 (pack (f1 a b)))
+	f1 (Vector2 (Vec2F a1 a2)) (Vector2 (Vec2F b1 b2)) = f (a1 :. a2 :.  ()) (b1 :. b2 :. ()) 
+
+instance Show Vector2 where
+	show = lift1 (Prelude.show)
+	
+instance Eq Vector2 where
+	(==) = lift2 (Prelude.==)
+	 
+instance Num Vector2 where
+	abs = lift1v (Prelude.abs)
+	signum = lift1v (Prelude.signum)
+	fromInteger = liftv (Prelude.fromInteger)
+
+	(+) = lift2v (Prelude.+)
+	(-) = lift2v (Prelude.-)
+	(*) = lift2v (Prelude.*)
+
+dotV2 :: Vector2 -> Vector2 -> Float
+dotV2 = lift2 Data.Vec.LinAlg.dot
+
+normSqV2 :: Vector2 -> Float
+normSqV2 = lift1 Data.Vec.LinAlg.normSq
+
+normV2 :: Vector2 -> Float
+normV2 = lift1 Data.Vec.LinAlg.norm
+
+normalizeV2 :: Vector2 -> Vector2
+normalizeV2 = lift1v Data.Vec.LinAlg.normalize
+
+scaleV2 :: Float -> Vector2 -> Vector2
+scaleV2 f (Vector2 v) = Vector2 (Data.Vec.Base.map (*f) v)
 
diff --git a/HGamer3D/Data/Vector3.hs b/HGamer3D/Data/Vector3.hs
--- a/HGamer3D/Data/Vector3.hs
+++ b/HGamer3D/Data/Vector3.hs
@@ -21,18 +21,105 @@
 module HGamer3D.Data.Vector3 
 
 (
-	-- export Vector3 Type again
-	Vector3 (Vector3),
+	-- export Vector3 Type and its functions again
 	
-	-- export all functions
+	Vector3 (Vector3),
+	vector3,
+	uniV3,
+	v3X,v3Y,v3Z,
+	HGamer3D.Data.Vector3.dotV3,
+	HGamer3D.Data.Vector3.normSqV3,
+	HGamer3D.Data.Vector3.normV3,
+	HGamer3D.Data.Vector3.normalizeV3,
+	HGamer3D.Data.Vector3.crossV3,
+	HGamer3D.Data.Vector3.scaleV3
 	
 )
 
 where
 
-data Vector3 = Vector3 {
-  v3X :: Float,
-  v3Y :: Float,
-  v3Z :: Float
-   } deriving (Eq, Show)
+import Data.Vec.Base
+import Data.Vec.Nat
+import Data.Vec.Packed
+import Data.Vec.LinAlg
+
+newtype Vector3 = Vector3 Vec3F
+
+vector3 :: Float -> Float -> Float -> Vector3
+vector3 a b c = Vector3 ( pack (a :. b :. c :. ()) )
+
+uniV3 :: Float -> Vector3
+uniV3 f = Vector3 (pack (vec f))
+
+v3X :: Vector3 -> Float
+v3X (Vector3 v3) = get n0 v3
+
+v3Y :: Vector3 -> Float
+v3Y (Vector3 v3) = get n1 v3
+
+v3Z :: Vector3 -> Float
+v3Z (Vector3 v3) = get n2 v3
+
+
+
+liftv :: (a -> Vec3F) -> (a -> Vector3)
+liftv f = f1 where
+	f1 a1 = (Vector3 (f a1)) 
+
+
+lift1 :: (Vec3F -> a) -> (Vector3 -> a)
+lift1 f = f1 where
+	f1 (Vector3 a1) = f a1 
+
+lift1v :: (Vec3F -> Vec3F) -> (Vector3 -> Vector3)
+lift1v f = f2 where
+	f2 a = (Vector3 (f1 a))
+	f1 (Vector3 a1) = f a1 
+
+lift2 :: (Vec3F -> Vec3F -> a) -> (Vector3 -> Vector3 -> a)
+lift2 f = f1 where
+	f1 (Vector3 a1) (Vector3 b1) = f a1 b1 
+
+lift2v :: (Vec3F -> Vec3F -> Vec3F) -> (Vector3 -> Vector3 -> Vector3)
+lift2v f = f2 where
+	f2 a b = (Vector3 (f1 a b))
+	f1 (Vector3 a1) (Vector3 b1) = f a1 b1 
+
+lift2vp :: (Vec3 Float -> Vec3 Float -> Vec3 Float) -> (Vector3 -> Vector3 -> Vector3)
+lift2vp f = f2 where
+	f2 a b = (Vector3 (pack (f1 a b)))
+	f1 (Vector3 (Vec3F a1 a2 a3)) (Vector3 (Vec3F b1 b2 b3)) = f (a1 :. a2 :. a3 :. ()) (b1 :. b2 :. b3 :. ()) 
+
+instance Show Vector3 where
+	show = lift1 (Prelude.show)
+	
+instance Eq Vector3 where
+	(==) = lift2 (Prelude.==)
+	 
+instance Num Vector3 where
+	abs = lift1v (Prelude.abs)
+	signum = lift1v (Prelude.signum)
+	fromInteger = liftv (Prelude.fromInteger)
+
+	(+) = lift2v (Prelude.+)
+	(-) = lift2v (Prelude.-)
+	(*) = lift2v (Prelude.*)
+
+dotV3 :: Vector3 -> Vector3 -> Float
+dotV3 = lift2 Data.Vec.LinAlg.dot
+
+normSqV3 :: Vector3 -> Float
+normSqV3 = lift1 Data.Vec.LinAlg.normSq
+
+normV3 :: Vector3 -> Float
+normV3 = lift1 Data.Vec.LinAlg.norm
+
+normalizeV3 :: Vector3 -> Vector3
+normalizeV3 = lift1v Data.Vec.LinAlg.normalize
+
+crossV3 :: Vector3 -> Vector3 -> Vector3
+crossV3 = lift2vp Data.Vec.LinAlg.cross
+
+scaleV3 :: Float -> Vector3 -> Vector3
+scaleV3 f (Vector3 v) = Vector3 (Data.Vec.Base.map (*f) v)
 
diff --git a/HGamer3D/Data/Vector4.hs b/HGamer3D/Data/Vector4.hs
--- a/HGamer3D/Data/Vector4.hs
+++ b/HGamer3D/Data/Vector4.hs
@@ -16,24 +16,110 @@
 -- See the License for the specific language governing permissions and
 -- limitations under the License.
 
--- Vector3.hs
+-- Vector4.hs
 
 module HGamer3D.Data.Vector4 
 
 (
-	-- export Vector4 Type again
-	Vector4 (Vector4),
+	-- export Vector4 Type and its functions again
 	
-	-- export all functions
+	Vector4 (Vector4),
+	vector4,
+	uniV4,
+	v4X,v4Y,v4Z,v4W,
+	HGamer3D.Data.Vector4.dotV4,
+	HGamer3D.Data.Vector4.normSqV4,
+	HGamer3D.Data.Vector4.normV4,
+	HGamer3D.Data.Vector4.normalizeV4,
+	HGamer3D.Data.Vector4.scaleV4
 	
 )
 
 where
 
-data Vector4 = Vector4 {
-  v4X :: Float,
-  v4Y :: Float,
-  v4Z :: Float,
-  v4W :: Float
-   } deriving (Eq, Show)
+import Data.Vec.Base
+import Data.Vec.Nat
+import Data.Vec.Packed
+import Data.Vec.LinAlg
+
+
+newtype Vector4 = Vector4 Vec4F
+
+vector4 :: Float -> Float -> Float -> Float -> Vector4
+vector4 a b c d = Vector4 ( pack (a :. b :. c :. d :. ()) )
+
+uniV4 :: Float -> Vector4
+uniV4 f = Vector4 (pack (vec f))
+
+v4X :: Vector4 -> Float
+v4X (Vector4 v4) = get n0 v4
+
+v4Y :: Vector4 -> Float
+v4Y (Vector4 v4) = get n1 v4
+
+v4Z :: Vector4 -> Float
+v4Z (Vector4 v4) = get n2 v4
+
+v4W :: Vector4 -> Float
+v4W (Vector4 v4) = get n3 v4
+
+
+
+liftv :: (a -> Vec4F) -> (a -> Vector4)
+liftv f = f1 where
+	f1 a1 = (Vector4 (f a1)) 
+
+
+lift1 :: (Vec4F -> a) -> (Vector4 -> a)
+lift1 f = f1 where
+	f1 (Vector4 a1) = f a1 
+
+lift1v :: (Vec4F -> Vec4F) -> (Vector4 -> Vector4)
+lift1v f = f2 where
+	f2 a = (Vector4 (f1 a))
+	f1 (Vector4 a1) = f a1 
+
+lift2 :: (Vec4F -> Vec4F -> a) -> (Vector4 -> Vector4 -> a)
+lift2 f = f1 where
+	f1 (Vector4 a1) (Vector4 b1) = f a1 b1 
+
+lift2v :: (Vec4F -> Vec4F -> Vec4F) -> (Vector4 -> Vector4 -> Vector4)
+lift2v f = f2 where
+	f2 a b = (Vector4 (f1 a b))
+	f1 (Vector4 a1) (Vector4 b1) = f a1 b1 
+
+lift2vp :: (Vec4 Float -> Vec4 Float -> Vec4 Float) -> (Vector4 -> Vector4 -> Vector4)
+lift2vp f = f2 where
+	f2 a b = (Vector4 (pack (f1 a b)))
+	f1 (Vector4 (Vec4F a1 a2 a3 a4)) (Vector4 (Vec4F b1 b2 b3 b4)) = f (a1 :. a2 :. a3 :. a4 :. ()) (b1 :. b2 :. b3 :. b4 :. ()) 
+
+instance Show Vector4 where
+	show = lift1 (Prelude.show)
+	
+instance Eq Vector4 where
+	(==) = lift2 (Prelude.==)
+	 
+instance Num Vector4 where
+	abs = lift1v (Prelude.abs)
+	signum = lift1v (Prelude.signum)
+	fromInteger = liftv (Prelude.fromInteger)
+
+	(+) = lift2v (Prelude.+)
+	(-) = lift2v (Prelude.-)
+	(*) = lift2v (Prelude.*)
+
+dotV4 :: Vector4 -> Vector4 -> Float
+dotV4 = lift2 Data.Vec.LinAlg.dot
+
+normSqV4 :: Vector4 -> Float
+normSqV4 = lift1 Data.Vec.LinAlg.normSq
+
+normV4 :: Vector4 -> Float
+normV4 = lift1 Data.Vec.LinAlg.norm
+
+normalizeV4 :: Vector4 -> Vector4
+normalizeV4 = lift1v Data.Vec.LinAlg.normalize
+
+scaleV4 :: Float -> Vector4 -> Vector4
+scaleV4 f (Vector4 v) = Vector4 (Data.Vec.Base.map (*f) v)