diff --git a/add_mesh_archimedean_solids.py b/add_mesh_archimedean_solids.py
index b21cf2f8bf7acc7469f38dc8246101ca63710c1e..40acdf36a1ed357ebdcf22b054fc00a75889db50 100644
--- a/add_mesh_archimedean_solids.py
+++ b/add_mesh_archimedean_solids.py
@@ -239,13 +239,13 @@ def add_rhombicuboctahedron(quad_size=sqrt(2.0) / (1.0 + sqrt(2) / 2.0)):
     for z, up in [(size / 2.0, True), (-size / 2.0, False)]:
         face = []
         face.append(len(verts))
-        verts.append(Vector(quad_size / 2.0, quad_size / 2.0, z))
+        verts.append(Vector((quad_size / 2.0, quad_size / 2.0, z)))
         face.append(len(verts))
-        verts.append(Vector(quad_size / 2.0, -quad_size / 2.0, z))
+        verts.append(Vector((quad_size / 2.0, -quad_size / 2.0, z)))
         face.append(len(verts))
-        verts.append(Vector(-quad_size / 2.0, -quad_size / 2.0, z))
+        verts.append(Vector((-quad_size / 2.0, -quad_size / 2.0, z)))
         face.append(len(verts))
-        verts.append(Vector(-quad_size / 2.0, quad_size / 2.0, z))
+        verts.append(Vector((-quad_size / 2.0, quad_size / 2.0, z)))
 
         if up:
             # Top face (quad)
@@ -260,21 +260,21 @@ def add_rhombicuboctahedron(quad_size=sqrt(2.0) / (1.0 + sqrt(2) / 2.0)):
         edgeloop = []
 
         edgeloop.append(len(verts))
-        verts.append(Vector(size / 2.0, quad_size / 2.0, z))
+        verts.append(Vector((size / 2.0, quad_size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(size / 2.0, -quad_size / 2.0, z))
+        verts.append(Vector((size / 2.0, -quad_size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(quad_size / 2.0, -size / 2.0, z))
+        verts.append(Vector((quad_size / 2.0, -size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(-quad_size / 2.0, -size / 2.0, z))
+        verts.append(Vector((-quad_size / 2.0, -size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(-size / 2.0, -quad_size / 2.0, z))
+        verts.append(Vector((-size / 2.0, -quad_size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(-size / 2.0, quad_size / 2.0, z))
+        verts.append(Vector((-size / 2.0, quad_size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(-quad_size / 2.0, size / 2.0, z))
+        verts.append(Vector((-quad_size / 2.0, size / 2.0, z)))
         edgeloop.append(len(verts))
-        verts.append(Vector(quad_size / 2.0, size / 2.0, z))
+        verts.append(Vector((quad_size / 2.0, size / 2.0, z)))
 
         if up:
             # Upper 8-sider
@@ -325,7 +325,7 @@ def get_polygon_center(verts, ngons):
     faces = []
 
     for f in ngons:
-        loc = Vector(0.0, 0.0, 0.0)
+        loc = Vector((0.0, 0.0, 0.0))
 
         for vert_idx in f:
             loc = loc + Vector(verts[vert_idx])
diff --git a/add_mesh_gemstones.py b/add_mesh_gemstones.py
index c394de71a730bb010c8c85a472a7168991a1cc8d..a9c1c34b35f8cb0eefacd402e513458e213ea07d 100755
--- a/add_mesh_gemstones.py
+++ b/add_mesh_gemstones.py
@@ -249,11 +249,11 @@ def add_gem(r1, r2, seg, h1, h2):
 
     # Tip
     vert_tip = len(verts)
-    verts.append(Vector(0.0, 0.0, -h1))
+    verts.append(Vector((0.0, 0.0, -h1)))
 
     # Middle vertex of the flat side (crown)
     vert_flat = len(verts)
-    verts.append(Vector(0.0, 0.0, h2))
+    verts.append(Vector((0.0, 0.0, h2)))
 
     edgeloop_flat = []
     for i in range(seg):
@@ -301,11 +301,11 @@ def add_diamond(segments, girdle_radius, table_radius,
 
     # Middle vertex of the flat side (crown)
     vert_flat = len(verts)
-    verts.append(Vector(0.0, 0.0, height_flat))
+    verts.append(Vector((0.0, 0.0, height_flat)))
 
     # Tip
     vert_tip = len(verts)
-    verts.append(Vector(0.0, 0.0, height_tip))
+    verts.append(Vector((0.0, 0.0, height_tip)))
 
     verts_flat = []
     verts_girdle = []
@@ -317,12 +317,12 @@ def add_diamond(segments, girdle_radius, table_radius,
 
         # Row for flat side
         verts_flat.append(len(verts))
-        vec = Vector(table_radius, 0.0, height_flat) * quat
+        vec = Vector((table_radius, 0.0, height_flat)) * quat
         verts.append(vec)
 
         # Row for the middle/girdle
         verts_girdle.append(len(verts))
-        vec = Vector(girdle_radius, 0.0, height_middle) * quat
+        vec = Vector((girdle_radius, 0.0, height_middle)) * quat
         verts.append(vec)
 
     # Flat face
diff --git a/add_mesh_spindle.py b/add_mesh_spindle.py
index 7e9243c4f4433a00d2883fbd713a1d0977c18106..9d870ca25610993bdb4cae45d723918a3fd31040 100644
--- a/add_mesh_spindle.py
+++ b/add_mesh_spindle.py
@@ -260,11 +260,11 @@ def add_spindle(segments, radius, height, cap_height):
 
     # Upper tip
     idx_upper_tip = len(verts)
-    verts.append(Vector(0, 0, half_height + cap_height))
+    verts.append(Vector((0, 0, half_height + cap_height)))
 
     # Lower tip
     idx_lower_tip = len(verts)
-    verts.append(Vector(0, 0, -half_height - cap_height))
+    verts.append(Vector((0.0, 0.0, -half_height - cap_height)))
 
     upper_edgeloop = []
     lower_edgeloop = []
@@ -274,12 +274,12 @@ def add_spindle(segments, radius, height, cap_height):
         # Calculate index & location of upper verte4x tip.
         idx_up = len(verts)
         upper_edgeloop.append(idx_up)
-        verts.append(Vector(radius, 0.0, half_height) * mtx)
+        verts.append(Vector((radius, 0.0, half_height)) * mtx)
 
         if height > 0:
             idx_low = len(verts)
             lower_edgeloop.append(idx_low)
-            verts.append(Vector(radius, 0.0, -half_height) * mtx)
+            verts.append(Vector((radius, 0.0, -half_height)) * mtx)
 
     # Create faces for the upper tip.
     tip_up_faces = createFaces([idx_upper_tip], upper_edgeloop,
diff --git a/add_mesh_star.py b/add_mesh_star.py
index 68bf6c53c6bfec13a07a56f74d207b1048469abf..ac83ae4d6d62b7d67dc9744b1c04042333dc2687 100644
--- a/add_mesh_star.py
+++ b/add_mesh_star.py
@@ -244,10 +244,10 @@ def add_star(points, outer_radius, inner_radius, height):
     half_height = height / 2.0
 
     vert_idx_top = len(verts)
-    verts.append(Vector(0.0, 0.0, half_height))
+    verts.append(Vector((0.0, 0.0, half_height)))
 
     vert_idx_bottom = len(verts)
-    verts.append(Vector(0.0, 0.0, -half_height))
+    verts.append(Vector((0.0, 0.0, -half_height)))
 
     edgeloop_top = []
     edgeloop_bottom = []
@@ -263,11 +263,11 @@ def add_star(points, outer_radius, inner_radius, height):
             radius = inner_radius
 
         edgeloop_top.append(len(verts))
-        vec = Vector(radius, 0, half_height) * quat
+        vec = Vector((radius, 0, half_height)) * quat
         verts.append(vec)
 
         edgeloop_bottom.append(len(verts))
-        vec = Vector(radius, 0, -half_height) * quat
+        vec = Vector((radius, 0, -half_height)) * quat
         verts.append(vec)
 
 
diff --git a/add_mesh_twisted_torus.py b/add_mesh_twisted_torus.py
index ce6677fba80f1424e11db434a87753c828902aae..cc8be0a3c1486ab4915b891fa279550f2855b2d3 100644
--- a/add_mesh_twisted_torus.py
+++ b/add_mesh_twisted_torus.py
@@ -271,10 +271,10 @@ def add_twisted_torus(major_rad, minor_rad, major_seg, minor_seg, twists):
         for minor_index in range(minor_seg):
             angle = (PI_2 * minor_index / minor_seg) + rot_twists
 
-            vec = Vector(
+            vec = Vector((
                 major_rad + (cos(angle) * minor_rad),
                 0.0,
-                sin(angle) * minor_rad)
+                sin(angle) * minor_rad))
             vec = vec * quat
 
             edgeloop.append(len(verts))
diff --git a/add_mesh_wedge.py b/add_mesh_wedge.py
index 3efb651be77e353de74e19f82f1d03fbb6610556..621f9d818baa0d5fd6745d0ef543a463a8a8b22c 100644
--- a/add_mesh_wedge.py
+++ b/add_mesh_wedge.py
@@ -262,19 +262,19 @@ def add_wedge(size_x, size_y, size_z):
     vIdx_bot = []
 
     vIdx_top.append(len(verts))
-    verts.append(Vector(-size_x, -size_y, size_z))
+    verts.append(Vector((-size_x, -size_y, size_z)))
     vIdx_bot.append(len(verts))
-    verts.append(Vector(-size_x, -size_y, -size_z))
+    verts.append(Vector((-size_x, -size_y, -size_z)))
 
     vIdx_top.append(len(verts))
-    verts.append(Vector(size_x, -size_y, size_z))
+    verts.append(Vector((size_x, -size_y, size_z)))
     vIdx_bot.append(len(verts))
-    verts.append(Vector(size_x, -size_y, -size_z))
+    verts.append(Vector((size_x, -size_y, -size_z)))
 
     vIdx_top.append(len(verts))
-    verts.append(Vector(-size_x, size_y, size_z))
+    verts.append(Vector((-size_x, size_y, size_z)))
     vIdx_bot.append(len(verts))
-    verts.append(Vector(-size_x, size_y, -size_z))
+    verts.append(Vector((-size_x, size_y, -size_z)))
 
     faces.append(vIdx_top)
     faces.append(vIdx_bot)
diff --git a/export_unreal_psk_psa.py b/export_unreal_psk_psa.py
index 348800806c356da577830385d3009476ff45061a..b24d00a903f56ee8631e77492f4d4270a0cd7e3b 100644
--- a/export_unreal_psk_psa.py
+++ b/export_unreal_psk_psa.py
@@ -1076,11 +1076,11 @@ def make_filename_ext(filename, extension):
 # (ie. the same as B*A if A and B are matrices representing 
 # the rotations described by quaternions a and b)
 def grassman(a, b):	
-	return mathutils.Quaternion(
+	return mathutils.Quaternion((
 		a.w*b.w - a.x*b.x - a.y*b.y - a.z*b.z,
 		a.w*b.x + a.x*b.w + a.y*b.z - a.z*b.y,
 		a.w*b.y - a.x*b.z + a.y*b.w + a.z*b.x,
-		a.w*b.z + a.x*b.y - a.y*b.x + a.z*b.w)
+		a.w*b.z + a.x*b.y - a.y*b.x + a.z*b.w))
 		
 def parse_animation(blender_scene, blender_armatures, psa_file):
 	#to do list:
diff --git a/import_scene_unreal_psk.py b/import_scene_unreal_psk.py
index f56f08d513e41a987b035485dafab102011958fa..85a490ff5cc41380cbd462f351f6a74f10b67204 100644
--- a/import_scene_unreal_psk.py
+++ b/import_scene_unreal_psk.py
@@ -57,8 +57,6 @@ from math import *
 
 import mathutils
 
-vector = mathutils.Vector
-
 #output log in to txt file
 DEBUGLOG = False
 
@@ -315,12 +313,12 @@ def pskimport(infile):
 		#w,x,y,z
 		if (counter == 0):#main parent
 			print("no parent bone")
-			createbone.bindmat = mathutils.Quaternion(indata[7],indata[4],indata[5],indata[6])
-			#createbone.bindmat = mathutils.Quaternion(indata[7],-indata[4],-indata[5],-indata[6])
+			createbone.bindmat = mathutils.Quaternion((indata[7],indata[4],indata[5],indata[6]))
+			#createbone.bindmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6]))
 		else:#parent
 			print("parent bone")
-			createbone.bindmat = mathutils.Quaternion(indata[7],-indata[4],-indata[5],-indata[6])
-			#createbone.bindmat = mathutils.Quaternion(indata[7],indata[4],indata[5],indata[6])
+			createbone.bindmat = mathutils.Quaternion((indata[7],-indata[4],-indata[5],-indata[6]))
+			#createbone.bindmat = mathutils.Quaternion((indata[7],indata[4],indata[5],indata[6]))
 			
 		md5_bones.append(createbone)
 		counter = counter + 1
@@ -392,7 +390,7 @@ def pskimport(infile):
 				
 				#parent_head = parentbone.head * parentbone.matrix.to_quat().inverse()
 				#parent_tail = parentbone.tail * parentbone.matrix.to_quat().inverse()
-				#location=vector(pos_x,pos_y,pos_z)
+				#location=Vector(pos_x,pos_y,pos_z)
 				#set_position = (parent_tail - parent_head) + location
 				#print("tmp head:",set_position)
 				
diff --git a/space_view3d_panel_measure.py b/space_view3d_panel_measure.py
index 35ffffbc60812cd8dee8aecf2cc79abbf7e14ef2..5d199a132acf69f94567b942cb75d8fce70b379b 100644
--- a/space_view3d_panel_measure.py
+++ b/space_view3d_panel_measure.py
@@ -193,7 +193,7 @@ def getMeasurePoints(context):
                 # local  ... the object center to the 3D cursor.
                 # global ... the origin to the 3D cursor.
                 cur_loc = sce.cursor_location
-                obj_loc = Vector(tuple(obj.location))
+                obj_loc = obj.location.copy()
 
                 # Convert to local space, if needed.
                 if measureLocal(sce):
@@ -202,7 +202,7 @@ def getMeasurePoints(context):
                     return (p1, p2, COLOR_GLOBAL)
 
                 else:
-                    p1 = Vector(0, 0, 0)
+                    p1 = Vector((0.0, 0.0, 0.0))
                     p2 = cur_loc
                     return (p1, p2, COLOR_GLOBAL)
 
@@ -211,8 +211,8 @@ def getMeasurePoints(context):
                 # We measure the distance from the
                 # selected vertex object to the 3D cursor.
                 cur_loc = sce.cursor_location
-                vert_loc = Vector(tuple(verts_selected[0].co))
-                obj_loc = Vector(tuple(obj.location))
+                vert_loc = verts_selected[0].co.copy()
+                obj_loc = obj.location.copy()
 
                 # Convert to local or global space.
                 if measureLocal(sce):
@@ -229,9 +229,9 @@ def getMeasurePoints(context):
                 # Two vertices selected.
                 # We measure the distance between the
                 # two selected vertices.
-                obj_loc = Vector(tuple(obj.location))
-                vert1_loc = Vector(tuple(verts_selected[0].co))
-                vert2_loc = Vector(tuple(verts_selected[1].co))
+                obj_loc = obj.location.copy()
+                vert1_loc = verts_selected[0].co.copy()
+                vert2_loc = verts_selected[1].co.copy()
 
                 # Convert to local or global space.
                 if measureLocal(sce):
@@ -264,13 +264,13 @@ def getMeasurePoints(context):
             # One object selected.
             # We measure the distance from the object to the 3D cursor.
             cur_loc = sce.cursor_location
-            obj_loc = Vector(tuple(obj.location))
+            obj_loc = obj.location.copy()
             return (obj_loc, cur_loc, COLOR_GLOBAL)
 
         elif not context.selected_objects:
             # Nothing selected.
             # We measure the distance from the origin to the 3D cursor.
-            p1 = Vector(0, 0, 0)
+            p1 = Vector((0.0, 0.0, 0.0))
             p2 = sce.cursor_location
             return (p1, p2, COLOR_GLOBAL)
 
@@ -302,10 +302,10 @@ def faceAreaGlobal(face, obj):
         v4 = obj.data.verts[v4]
 
         # Apply transform matrix to vertex coordinates.
-        v1 = Vector(tuple(v1.co)) * mat
-        v2 = Vector(tuple(v2.co)) * mat
-        v3 = Vector(tuple(v3.co)) * mat
-        v4 = Vector(tuple(v4.co)) * mat
+        v1 = v1.co * mat
+        v2 = v2.co * mat
+        v3 = v3.co * mat
+        v4 = v4.co * mat
 
         vec1 = v2 - v1
         vec2 = v4 - v1
@@ -333,9 +333,9 @@ def faceAreaGlobal(face, obj):
         v3 = obj.data.verts[v3]
 
         # Apply transform matrix to vertex coordinates.
-        v1 = Vector(tuple(v1.co)) * mat
-        v2 = Vector(tuple(v2.co)) * mat
-        v3 = Vector(tuple(v3.co)) * mat
+        v1 = v1.co * mat
+        v2 = v2.co * mat
+        v3 = v3.co * mat
 
         vec1 = v3 - v2
         vec2 = v1 - v2
@@ -398,18 +398,18 @@ def region3d_get_2d_coordinates(context, loc_3d):
     total_mat = view_mat
 
     # order is important
-    vec = total_mat * Vector(loc_3d[0], loc_3d[1], loc_3d[2], 1.0)
+    vec = total_mat * Vector((loc_3d[0], loc_3d[1], loc_3d[2], 1.0))
 
     # dehomogenise
-    vec = Vector(
+    vec = Vector((
         vec[0] / vec[3],
         vec[1] / vec[3],
-        vec[2] / vec[3])
+        vec[2] / vec[3]))
 
     x = int(mid_x + vec[0] * width / 2.0)
     y = int(mid_y + vec[1] * height / 2.0)
 
-    return Vector(x, y, 0)
+    return Vector((x, y, 0))
 
 
 def draw_measurements_callback(self, context):