diff --git a/compiler/fn.v b/compiler/fn.v
index daae71da7a..c65043473f 100644
--- a/compiler/fn.v
+++ b/compiler/fn.v
@@ -14,7 +14,7 @@ struct Fn {
 	// addr int
 mut:
 	name          string
-	pkg           string
+	mod           string
 	local_vars    []Var
 	var_idx       int
 	args          []Var
@@ -97,9 +97,9 @@ fn (p mut Parser) is_sig() bool {
 	(p.file_path.contains(ModPath))
 }
 
-fn new_fn(pkg string, is_public bool) *Fn {
+fn new_fn(mod string, is_public bool) *Fn {
 	return &Fn {
-		pkg: pkg
+		mod: mod
 		local_vars: [Var{}		; MaxLocalVars]
 		is_public: is_public
 	}
@@ -137,13 +137,13 @@ fn (p mut Parser) fn_decl() {
 			p.error('invalid receiver type `$receiver_typ` (`$receiver_typ` is an interface)')
 		}
 		// Don't allow modifying types from a different module
-		if !p.first_pass() && !p.builtin_pkg && T.mod != p.mod {
+		if !p.first_pass() && !p.builtin_mod && T.mod != p.mod {
 			println('T.mod=$T.mod')
 			println('p.mod=$p.mod')
 			p.error('cannot define new methods on non-local type `$receiver_typ`')
 		}
 		// (a *Foo) instead of (a mut Foo) is a common mistake
-		if !p.builtin_pkg && receiver_typ.contains('*') {
+		if !p.builtin_mod && receiver_typ.contains('*') {
 			t := receiver_typ.replace('*', '')
 			p.error('use `($receiver_name mut $t)` instead of `($receiver_name *$t)`')
 		}
@@ -175,10 +175,10 @@ fn (p mut Parser) fn_decl() {
 	// C function header def? (fn C.NSMakeRect(int,int,int,int))
 	is_c := f.name == 'C' && p.tok == .dot 
 	// Just fn signature? only builtin.v + default build mode
-	// is_sig := p.builtin_pkg && p.pref.build_mode == default_mode
-	// is_sig := p.pref.build_mode == default_mode && (p.builtin_pkg || p.file.contains(LANG_TMP))
+	// is_sig := p.builtin_mod && p.pref.build_mode == default_mode
+	// is_sig := p.pref.build_mode == default_mode && (p.builtin_mod || p.file.contains(LANG_TMP))
 	is_sig := p.is_sig()
-	// println('\n\nfn decl !!is_sig=$is_sig name=$f.name $p.builtin_pkg')
+	// println('\n\nfn decl !!is_sig=$is_sig name=$f.name $p.builtin_mod')
 	if is_c {
 		p.check(.dot)
 		f.name = p.check_name()
@@ -199,10 +199,10 @@ fn (p mut Parser) fn_decl() {
 	if receiver_typ != '' {
 		// f.name = '${receiver_typ}_${f.name}'
 	}
-	// full pkg function name
+	// full mod function name
 	// os.exit ==> os__exit()
-	if !is_c && !p.builtin_pkg && p.mod != 'main' && receiver_typ.len == 0 {
-		f.name = p.prepend_pkg(f.name)
+	if !is_c && !p.builtin_mod && p.mod != 'main' && receiver_typ.len == 0 {
+		f.name = p.prepend_mod(f.name)
 	}
 	if p.first_pass() && p.table.known_fn(f.name) && receiver_typ.len == 0 {
 		existing_fn := p.table.find_fn(f.name)
@@ -471,7 +471,7 @@ _thread_so = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&reload_so, 0, 0, 0);
 		// p.error('unclosed {')
 	}
 	// Make sure all vars in this function are used (only in main for now)
-	// if p.builtin_pkg || p.mod == 'os' ||p.mod=='http'{
+	// if p.builtin_mod || p.mod == 'os' ||p.mod=='http'{
 	if p.mod != 'main' {
 		if !is_generic { 
 			p.genln('}')
@@ -580,11 +580,11 @@ fn (p mut Parser) async_fn_call(f Fn, method_ph int, receiver_var, receiver_type
 }
 
 fn (p mut Parser) fn_call(f Fn, method_ph int, receiver_var, receiver_type string) {
-	if !f.is_public &&  !f.is_c && !p.pref.is_test && !f.is_interface && f.pkg != p.mod  { 
+	if !f.is_public &&  !f.is_c && !p.pref.is_test && !f.is_interface && f.mod != p.mod  { 
 		p.error('function `$f.name` is private')
 	}
 	p.calling_c = f.is_c
-	if f.is_c && !p.builtin_pkg {
+	if f.is_c && !p.builtin_mod {
 		if f.name == 'free' {
 			p.error('use `free()` instead of `C.free()`') 
 		} else if f.name == 'malloc' {
diff --git a/compiler/jsgen.v b/compiler/jsgen.v
index 55b5758101..9fc9a7b246 100644
--- a/compiler/jsgen.v
+++ b/compiler/jsgen.v
@@ -28,7 +28,7 @@ fn (p mut Parser) gen_json_for_type(typ Type) {
 	// println('gen_json_for_type( $typ.name )')
 	// Register decoder fn
 	mut dec_fn := Fn {
-		pkg: p.mod
+		mod: p.mod
 		typ: 'Option_$typ.name'
 		name: js_dec_name(t)
 	}
@@ -45,7 +45,7 @@ fn (p mut Parser) gen_json_for_type(typ Type) {
 	p.table.register_fn(dec_fn)
 	// Register encoder fn
 	mut enc_fn := Fn {
-		pkg: p.mod
+		mod: p.mod
 		typ: 'cJSON*'
 		name: js_enc_name(t)
 	}
diff --git a/compiler/main.v b/compiler/main.v
index 466f90445c..f2306f1744 100644
--- a/compiler/main.v
+++ b/compiler/main.v
@@ -946,19 +946,15 @@ fn (v mut V) add_v_files_to_compile() {
 		v.log('user_files:')
 		println(user_files)
 	}
-	// import tables for user/lib files
-	mut file_imports := []FileImportTable
 	// Parse builtin imports
 	for file in v.files {
 		mut p := v.new_parser(file, Pass.imports)
 		p.parse()
-		file_imports << *p.import_table
 	}
 	// Parse user imports
 	for file in user_files {
 		mut p := v.new_parser(file, Pass.imports)
 		p.parse()
-		file_imports << *p.import_table
 	}
 	// Parse lib imports
 /* 
@@ -977,7 +973,6 @@ fn (v mut V) add_v_files_to_compile() {
 			for file in vfiles {
 				mut p := v.new_parser(file, Pass.imports)
 				p.parse()
-				file_imports << *p.import_table
 			}
 		}
 	}
@@ -996,7 +991,6 @@ fn (v mut V) add_v_files_to_compile() {
 		for file in vfiles {
 			mut p := v.new_parser(file, Pass.imports)
 			p.parse()
-			file_imports << *p.import_table
 		}
 	}
 	if v.pref.is_verbose {
@@ -1005,7 +999,7 @@ fn (v mut V) add_v_files_to_compile() {
 	}
 	// graph deps
 	mut dep_graph := new_mod_dep_graph()
-	dep_graph.from_import_tables(file_imports)
+	dep_graph.from_import_tables(v.table.file_imports)
 	deps_resolved := dep_graph.resolve()
 	if !deps_resolved.acyclic {
 		deps_resolved.display()
@@ -1034,7 +1028,7 @@ fn (v mut V) add_v_files_to_compile() {
 		}
 	}
 	// add remaining files (not modules)
-	for fit in file_imports {
+	for fit in v.table.file_imports {
 		//println('fit $fit.file_path') 
 		if !fit.file_path in v.files {
 			v.files << fit.file_path
@@ -1058,13 +1052,13 @@ fn get_arg(joined_args, arg, def string) string {
 	return res
 }
 
-fn (v &V) module_path(pkg string) string {
+fn (v &V) module_path(mod string) string {
 	// submodule support
-	if pkg.contains('.') {
-		//return pkg.replace('.', path_sep)
-		return pkg.replace('.', '/')
+	if mod.contains('.') {
+		//return mod.replace('.', path_sep)
+		return mod.replace('.', '/')
 	}
-	return pkg
+	return mod
 }
 
 fn (v &V) log(s string) {
diff --git a/compiler/parser.v b/compiler/parser.v
index d9e44a2bd0..097bc1ac39 100644
--- a/compiler/parser.v
+++ b/compiler/parser.v
@@ -62,7 +62,7 @@ mut:
 	tmp_cnt        int
 	is_script      bool
 	pref           *Preferences // Setting and Preferences shared from V struct
-	builtin_pkg    bool
+	builtin_mod    bool
 	vh_lines       []string
 	inside_if_expr bool
 	is_struct_init bool
@@ -184,13 +184,13 @@ fn (p mut Parser) parse() {
 		p.mod = p.check_name()
 	}
 	p.fgenln('\n')
-	p.builtin_pkg = p.mod == 'builtin'
+	p.builtin_mod = p.mod == 'builtin'
 	p.can_chash = p.mod == 'ft' || 	p.mod == 'glfw'  || p.mod=='glfw2' || p.mod=='ui' // TODO tmp remove
 	// Import pass - the first and the smallest pass that only analyzes imports
 	// fully qualify the module name, eg base64 to encoding.base64
 	fq_mod := p.table.qualify_module(p.mod, p.file_path)
 	p.import_table.module_name = fq_mod
-	p.table.register_package(fq_mod)
+	p.table.register_module(fq_mod)
 	// replace "." with "_dot_" in module name for C variable names
 	p.mod = fq_mod.replace('.', '_dot_')
 	if p.pass == .imports {
@@ -199,7 +199,9 @@ fn (p mut Parser) parse() {
 		}
 		if p.table.imports.contains('builtin') {
 			p.error('module `builtin` cannot be imported') 
-		} 
+		}
+		// save file import table
+		p.table.file_imports << *p.import_table
 		return
 	}
 	// Go through every top level token or throw a compilation error if a non-top level token is met
@@ -264,7 +266,7 @@ fn (p mut Parser) parse() {
 			p.comp_time()
 		case Token.key_global:
 			if !p.pref.translated && !p.pref.is_live && 
-				!p.builtin_pkg && !p.building_v {
+				!p.builtin_mod && !p.building_v {
 				p.error('__global is only allowed in translated code')
 			}
 			p.next()
@@ -362,18 +364,18 @@ fn (p mut Parser) import_statement() {
 	if p.peek() == .number && p.scanner.text[p.scanner.pos + 1] == `.` {
 		p.error('bad import format. module/submodule names cannot begin with a number.')
 	}
-	mut pkg := p.check_name().trim_space()
-	mut mod_alias := pkg
+	mut mod := p.check_name().trim_space()
+	mut mod_alias := mod
 	// submodule support
 	mut depth := 1
 	for p.tok == .dot {
 		p.check(.dot) 
 		submodule := p.check_name()
 		mod_alias = submodule
-		pkg += '.' + submodule
+		mod += '.' + submodule
 		depth++
 		if depth > MaxModuleDepth { 
-			p.error('module depth of $MaxModuleDepth exceeded: $pkg') 
+			p.error('module depth of $MaxModuleDepth exceeded: $mod') 
 		}
 	}
 	// aliasing (import encoding.base64 as b64)
@@ -382,16 +384,16 @@ fn (p mut Parser) import_statement() {
 		mod_alias = p.check_name()
 	}
 	// add import to file scope import table
-	p.import_table.register_alias(mod_alias, pkg)
+	p.import_table.register_alias(mod_alias, mod)
 	// Make sure there are no duplicate imports
-	if p.table.imports.contains(pkg) {
+	if p.table.imports.contains(mod) {
 		return
 	}
-	p.log('adding import $pkg')
-	p.table.imports << pkg
-	p.table.register_package(pkg)
+	p.log('adding import $mod')
+	p.table.imports << mod
+	p.table.register_module(mod)
 	
-	p.fgenln(' ' + pkg)
+	p.fgenln(' ' + mod)
 }
 
 fn (p mut Parser) const_decl() {
@@ -411,9 +413,9 @@ fn (p mut Parser) const_decl() {
 		//if ! (name[0] >= `A` && name[0] <= `Z`) {
 			//p.error('const name must be capitalized')
 		//}
-		// Imported consts (like GL_TRIANG.leS) dont need pkg prepended (gl__GL_TRIANG.leS)
+		// Imported consts (like GL_TRIANG.leS) dont need mod prepended (gl__GL_TRIANG.leS)
 		if !is_import {
-			name = p.prepend_pkg(name)
+			name = p.prepend_mod(name)
 		}
 		mut typ := 'int'
 		if !is_import {
@@ -525,8 +527,8 @@ fn (p mut Parser) struct_decl() {
 		p.error('bad struct name, e.g. use `HttpRequest` instead of `HTTPRequest`')  
 	} 
 	// Specify full type name
-	if !is_c && !p.builtin_pkg && p.mod != 'main' {
-		name = p.prepend_pkg(name)
+	if !is_c && !p.builtin_mod && p.mod != 'main' {
+		name = p.prepend_mod(name)
 	}
 	if p.pass == .decl && p.table.known_type(name) {
 		p.error('`$name` redeclared')
@@ -682,8 +684,8 @@ fn (p mut Parser) struct_decl() {
 fn (p mut Parser) enum_decl(_enum_name string) {
 	mut enum_name := _enum_name
 	// Specify full type name
-	if !p.builtin_pkg && p.mod != 'main' {
-		enum_name = p.prepend_pkg(enum_name)
+	if !p.builtin_mod && p.mod != 'main' {
+		enum_name = p.prepend_mod(enum_name)
 	}
 	// Skip empty enums
 	if enum_name != 'int' {
@@ -822,7 +824,7 @@ fn (p mut Parser) get_type() string {
 		if debug {
 			println('\nget_type() .key_goT FN TYP line=$p.scanner.line_nr')
 		}
-		mut f := Fn{name: '_', pkg: p.mod}
+		mut f := Fn{name: '_', mod: p.mod}
 		p.next()
 		line_nr := p.scanner.line_nr
 		p.fn_args(mut f)
@@ -883,7 +885,7 @@ fn (p mut Parser) get_type() string {
 		}
 	}
 	// map[string]int 
-	if !p.builtin_pkg && p.tok == .name && p.lit == 'map' {
+	if !p.builtin_mod && p.tok == .name && p.lit == 'map' {
 		p.next()
 		p.check(.lsbr) 
 		key_type := p.check_name() 
@@ -919,19 +921,19 @@ fn (p mut Parser) get_type() string {
 		typ = p.lit
 	}
 	else {
-		// Package specified? (e.g. gx.Image)
+		// Module specified? (e.g. gx.Image)
 		if p.peek() == .dot {
 			p.next()
 			p.check(.dot)
 			typ += '__$p.lit'
 		}
 		mut t := p.table.find_type(typ)
-		// "typ" not found? try "pkg__typ"
-		if t.name == '' && !p.builtin_pkg {
+		// "typ" not found? try "mod__typ"
+		if t.name == '' && !p.builtin_mod {
 			// && !p.first_pass() {
 			if !typ.contains('array_') && p.mod != 'main' && !typ.contains('__') &&
 				!typ.starts_with('[') { 
-				typ = p.prepend_pkg(typ)
+				typ = p.prepend_mod(typ)
 			}
 			t = p.table.find_type(typ)
 			if t.name == '' && !p.pref.translated && !p.first_pass() && !typ.starts_with('[') {
@@ -974,7 +976,7 @@ fn (p mut Parser) get_type() string {
 		return 'byte*'
 	}
 	if typ == 'voidptr' {
-		//if !p.builtin_pkg && p.mod != 'os' && p.mod != 'gx' && p.mod != 'gg' && !p.pref.translated {
+		//if !p.builtin_mod && p.mod != 'os' && p.mod != 'gx' && p.mod != 'gg' && !p.pref.translated {
 			//p.error('voidptr can only be used in unsafe code')
 		//}
 		return 'void*'
@@ -1225,7 +1227,7 @@ fn (p mut Parser) assign_statement(v Var, ph int, is_map bool) {
 		//p.cgen.cur_line = left + 'opt_ok($expr)'
 		p.cgen.resetln(left + 'opt_ok($expr, sizeof($expr_type))')
 	}
-	else if !p.builtin_pkg && !p.check_types_no_throw(expr_type, p.assigned_type) {
+	else if !p.builtin_mod && !p.check_types_no_throw(expr_type, p.assigned_type) {
 		p.scanner.line_nr--
 		p.error('cannot use type `$expr_type` as type `$p.assigned_type` in assignment')
 	}
@@ -1256,7 +1258,7 @@ fn (p mut Parser) var_decl() {
 	p.var_decl_name = name 
 	// Don't allow declaring a variable with the same name. Even in a child scope
 	// (shadowing is not allowed)
-	if !p.builtin_pkg && p.cur_fn.known_var(name) {
+	if !p.builtin_mod && p.cur_fn.known_var(name) {
 		v := p.cur_fn.find_var(name)
 		p.error('redefinition of `$name`')
 	}
@@ -1395,7 +1397,7 @@ fn (p mut Parser) name_expr() string {
 		p.next()
 	}
 	if deref {
-		if p.pref.is_play && !p.builtin_pkg {
+		if p.pref.is_play && !p.builtin_mod {
 			p.error('dereferencing is temporarily disabled on the playground, will be fixed soon')
 		}
 	}
@@ -1433,23 +1435,23 @@ fn (p mut Parser) name_expr() string {
 	// //////////////////////////
 	// module ?
 	// Allow shadowing (gg = gg.newcontext(); gg.draw_triangle())
-	if ((name == p.mod && p.table.known_pkg(name)) || p.import_table.known_alias(name))
+	if ((name == p.mod && p.table.known_mod(name)) || p.import_table.known_alias(name))
 		&& !p.cur_fn.known_var(name) && !is_c {
-		mut pkg := name
+		mut mod := name
 		// must be aliased module
 		if name != p.mod && p.import_table.known_alias(name) {
 			// we replaced "." with "_dot_" in p.mod for C variable names, do same here.
-			pkg = p.import_table.resolve_alias(name).replace('.', '_dot_')
+			mod = p.import_table.resolve_alias(name).replace('.', '_dot_')
 		}
 		p.next()
 		p.check(.dot)
 		name = p.lit
 		p.fgen(name)
-		name = prepend_pkg(pkg, name)
+		name = prepend_mod(mod, name)
 	}
 	else if !p.table.known_type(name) && !p.cur_fn.known_var(name) &&
 	!p.table.known_fn(name) && !p.table.known_const(name) && !is_c {
-		name = p.prepend_pkg(name)
+		name = p.prepend_mod(name)
 	}
 	// Variable
 	mut v := p.cur_fn.find_var(name)
@@ -1517,7 +1519,7 @@ fn (p mut Parser) name_expr() string {
 			return enum_type.name
 		}
 		else if p.peek() == .lcbr {
-			// go back to name start (pkg.name)
+			// go back to name start (mod.name)
 /* 
 			p.scanner.pos = hack_pos
 			p.tok = hack_tok
@@ -1582,9 +1584,9 @@ fn (p mut Parser) name_expr() string {
 				f = p.table.find_fn(name) 
 			} 
 			if f.name == '' { 
-				// If orig_name is a pkg, then printing undefined: `pkg` tells us nothing
-				// if p.table.known_pkg(orig_name) {
-				if p.table.known_pkg(orig_name) || p.import_table.known_alias(orig_name) {
+				// If orig_name is a mod, then printing undefined: `mod` tells us nothing
+				// if p.table.known_mod(orig_name) {
+				if p.table.known_mod(orig_name) || p.import_table.known_alias(orig_name) {
 					name = name.replace('__', '.').replace('_dot_', '.')
 					p.error('undefined: `$name`')
 				}
@@ -1750,21 +1752,21 @@ fn (p mut Parser) dot(str_typ string, method_ph int) string {
 		next := p.peek()
 		modifying := next.is_assign() || next == .inc || next == .dec
 		is_vi := p.fileis('vi')
-		if !p.builtin_pkg && !p.pref.translated && modifying && !field.is_mut && !is_vi {
+		if !p.builtin_mod && !p.pref.translated && modifying && !field.is_mut && !is_vi {
 			p.error('cannot modify immutable field `$field_name` (type `$typ.name`)')
 		}
-		if !p.builtin_pkg && p.mod != typ.mod {
+		if !p.builtin_mod && p.mod != typ.mod {
 		}
-		// if p.pref.is_play && field.access_mod ==.private && !p.builtin_pkg && p.mod != typ.mod {
+		// if p.pref.is_play && field.access_mod ==.private && !p.builtin_mod && p.mod != typ.mod {
 		// Don't allow `arr.data`
-		if field.access_mod == .private && !p.builtin_pkg && !p.pref.translated && p.mod != typ.mod {
+		if field.access_mod == .private && !p.builtin_mod && !p.pref.translated && p.mod != typ.mod {
 			// println('$typ.name :: $field.name ')
 			// println(field.access_mod)
 			p.error('cannot refer to unexported field `$field_name` (type `$typ.name`)')
 		}
-		// if field.access_mod ==.public && p.peek() == .assign && !p.builtin_pkg && p.mod != typ.mod {
+		// if field.access_mod ==.public && p.peek() == .assign && !p.builtin_mod && p.mod != typ.mod {
 		// Don't allow `str.len = 0`
-		if field.access_mod == .public && !p.builtin_pkg && p.mod != typ.mod {
+		if field.access_mod == .public && !p.builtin_mod && p.mod != typ.mod {
 			if !field.is_mut && !p.pref.translated && modifying {
 				p.error('cannot modify public immutable field `$field_name` (type `$typ.name`)')
 			}
@@ -1815,8 +1817,8 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 		if is_str {
 			typ = 'byte'
 			p.fgen('[')
-			// Direct faster access to .str[i] in builtin package
-			if p.builtin_pkg {
+			// Direct faster access to .str[i] in builtin modules
+			if p.builtin_mod {
 				p.gen('.str[')
 				close_bracket = true
 			}
@@ -1866,7 +1868,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 				typ = 'void*'
 			}
 			// No bounds check in translated from C code
-			if p.pref.translated && !p.builtin_pkg{
+			if p.pref.translated && !p.builtin_mod{
 				// Cast void* to typ*: add (typ*) to the beginning of the assignment :
 				// ((int*)a.data = ...
 				p.cgen.set_placeholder(fn_ph, '(($typ*)(')
@@ -1898,7 +1900,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 			p.expression()
 		}
 		p.check(.rsbr)
-		// if (is_str && p.builtin_pkg) || is_ptr || is_fixed_arr && ! (is_ptr && is_arr) {
+		// if (is_str && p.builtin_mod) || is_ptr || is_fixed_arr && ! (is_ptr && is_arr) {
 		if close_bracket {
 			p.gen(']/*r$typ $v.is_mut*/')
 		}
@@ -1910,7 +1912,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 	p.tok == .mult_assign || p.tok == .div_assign || p.tok == .xor_assign || p.tok == .mod_assign ||
 	p.tok == .or_assign || p.tok == .and_assign || p.tok == .righ_shift_assign ||
 	p.tok == .left_shift_assign {
-		if is_indexer && is_str && !p.builtin_pkg {
+		if is_indexer && is_str && !p.builtin_mod {
 			p.error('strings are immutable')
 		}
 		assign_pos := p.cgen.cur_line.len
@@ -1948,7 +1950,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 	// p.error('didnt assign')
 	// }
 	// m[key]. no =, just a getter
-	else if (is_map || is_arr || (is_str && !p.builtin_pkg)) && is_indexer {
+	else if (is_map || is_arr || (is_str && !p.builtin_mod)) && is_indexer {
 		// Erase var name we generated earlier:	"int a = m, 0"
 		// "m, 0" gets killed since we need to start from scratch. It's messy.
 		// "m, 0" is an index expression, save it before deleting and insert later in map_get()
@@ -1966,7 +1968,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 			p.cgen.insert_before('$typ $tmp = $def; bool $tmp_ok = map_get($index_expr, & $tmp);')
 		}
 		else if is_arr {
-			if p.pref.translated && !p.builtin_pkg {
+			if p.pref.translated && !p.builtin_mod {
 				p.gen('$index_expr ]')
 			}
 			else {
@@ -1977,7 +1979,7 @@ fn (p mut Parser) index_expr(typ string, fn_ph int) string {
 				} 
 			}
 		}
-		else if is_str && !p.builtin_pkg {
+		else if is_str && !p.builtin_mod {
 			p.gen('string_at($index_expr)')
 		}
 		// Zero the string after map_get() if it's nil, numbers are automatically 0
@@ -2536,7 +2538,7 @@ fn (p mut Parser) array_init() string {
 	// fixed length arrays with a const len: `nums := [N]int`, same as `[10]int` basically 
 	mut is_const_len := false 
 	if p.tok == .name {
-		c := p.table.find_const(p.prepend_pkg(p.lit)) 
+		c := p.table.find_const(p.prepend_mod(p.lit)) 
 		if c.name != '' && c.typ == 'int' && p.peek() == .rsbr && !p.inside_const {
 			is_integer = true 
 			is_const_len = true 
@@ -2733,7 +2735,7 @@ fn (p mut Parser) struct_init(typ string, is_c_struct_init bool) string {
 				continue
 			}
 			field_typ := field.typ
-			if !p.builtin_pkg && field_typ.ends_with('*') && field_typ.contains('Cfg') {
+			if !p.builtin_mod && field_typ.ends_with('*') && field_typ.contains('Cfg') {
 				p.error('pointer field `${typ}.${field.name}` must be initialized')
 			}
 			def_val := type_default(field_typ)
@@ -3255,12 +3257,12 @@ fn (p mut Parser) return_st() {
 	p.returns = true
 }
 
-fn prepend_pkg(pkg, name string) string {
-	return '${pkg}__${name}'
+fn prepend_mod(mod, name string) string {
+	return '${mod}__${name}'
 }
 
-fn (p &Parser) prepend_pkg(name string) string {
-	return prepend_pkg(p.mod, name)
+fn (p &Parser) prepend_mod(name string) string {
+	return prepend_mod(p.mod, name)
 }
 
 fn (p mut Parser) go_statement() {
diff --git a/compiler/table.v b/compiler/table.v
index 9d0f197f2d..80ac06f90b 100644
--- a/compiler/table.v
+++ b/compiler/table.v
@@ -9,16 +9,17 @@ import strings
 
 struct Table {
 mut:
-	types     []Type
-	consts    []Var
-	fns       map[string]Fn 
-	generic_fns []GenTable //map[string]GenTable // generic_fns['listen_and_serve'] == ['Blog', 'Forum'] 
-	obf_ids   map[string]int // obf_ids['myfunction'] == 23
-	packages  []string // List of all modules registered by the application
-	imports   []string // List of all imports
-	flags     []string //  ['-framework Cocoa', '-lglfw3']
-	fn_cnt    int atomic
-	obfuscate bool
+	types        []Type
+	consts       []Var
+	fns          map[string]Fn 
+	generic_fns  []GenTable //map[string]GenTable // generic_fns['listen_and_serve'] == ['Blog', 'Forum'] 
+	obf_ids      map[string]int // obf_ids['myfunction'] == 23
+	modules      []string // List of all modules registered by the application
+	imports      []string // List of all imports
+	file_imports []FileImportTable // List of imports for file
+	flags        []string //  ['-framework Cocoa', '-lglfw3']
+	fn_cnt       int atomic
+	obfuscate    bool
 }
 
 struct GenTable {
@@ -140,6 +141,7 @@ fn new_table(obfuscate bool) *Table {
 		//generic_fns: map[string]GenTable{} 
 		generic_fns: []GenTable 
 		obfuscate: obfuscate
+		file_imports: []FileImportTable
 	}
 	t.register_type('int')
 	t.register_type('size_t')
@@ -181,11 +183,11 @@ fn (t mut Table) var_cgen_name(name string) string {
 	}
 }
 
-fn (t mut Table) register_package(pkg string) {
-	if t.packages.contains(pkg) {
+fn (t mut Table) register_module(mod string) {
+	if t.modules.contains(mod) {
 		return
 	}
-	t.packages << pkg
+	t.modules << mod
 }
 
 fn (p mut Parser) register_array(typ string) {
@@ -210,8 +212,8 @@ fn (p mut Parser) register_map(typ string) {
 	}
 }
 
-fn (table &Table) known_pkg(pkg string) bool {
-	return pkg in table.packages
+fn (table &Table) known_mod(mod string) bool {
+	return mod in table.modules
 }
 
 fn (t mut Table) register_const(name, typ, mod string, is_imported bool) {
@@ -308,9 +310,9 @@ fn (t mut Table) register_type_with_parent(typ, parent string) {
 		}
 	}
 	/*
-mut pkg := ''
+mut mod := ''
 if parent == 'array' {
-pkg = 'builtin'
+mod = 'builtin'
 }
 */
 	t.types << Type { 
@@ -433,7 +435,7 @@ fn (t mut Type) add_gen_type(type_name string) {
 fn (p &Parser) find_type(name string) *Type {
 	typ := p.table.find_type(name)
 	if typ.name.len == 0 {
-		return p.table.find_type(p.prepend_pkg(name))
+		return p.table.find_type(p.prepend_mod(name))
 	}
 	return typ
 }
@@ -481,7 +483,7 @@ fn (p mut Parser) _check_types(got, expected string, throw bool) bool {
 	}
 	// Todo void* allows everything right now
 	if got=='void*' || expected=='void*' {
-		// if !p.builtin_pkg {
+		// if !p.builtin_mod {
 		if p.pref.is_play {
 			return false
 		}
@@ -655,14 +657,14 @@ fn (table mut Table) cgen_name(f &Fn) string {
 	// Avoid name conflicts (with things like abs(), print() etc).
 	// Generate b_abs(), b_print()
 	// TODO duplicate functionality
-	if f.pkg == 'builtin' && CReserved.contains(f.name) {
+	if f.mod == 'builtin' && CReserved.contains(f.name) {
 		return 'v_$name'
 	}
 	// Obfuscate but skip certain names
 	// TODO ugly, fix
-	if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.pkg != 'builtin' && !f.is_c &&
-	f.pkg != 'darwin' && f.pkg != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' &&
-	f.name != 'build_token_str' && f.name != 'build_keys' && f.pkg != 'json' &&
+	if table.obfuscate && f.name != 'main' && f.name != 'WinMain' && f.mod != 'builtin' && !f.is_c &&
+	f.mod != 'darwin' && f.mod != 'os' && !f.name.contains('window_proc') && f.name != 'gg__vec2' &&
+	f.name != 'build_token_str' && f.name != 'build_keys' && f.mod != 'json' &&
 	!name.ends_with('_str') && !name.contains('contains') {
 		mut idx := table.obf_ids[name]
 		// No such function yet, register it