diff --git a/cmd/tools/vfmt.v b/cmd/tools/vfmt.v
index e2fada1a88..731ca01cbd 100644
--- a/cmd/tools/vfmt.v
+++ b/cmd/tools/vfmt.v
@@ -18,6 +18,7 @@ import (
 struct FormatOptions {
 	is_l       bool
 	is_c       bool
+	is_js	   bool
 	is_w       bool
 	is_diff    bool
 	is_verbose bool
@@ -51,6 +52,7 @@ fn main() {
 	args := util.join_env_vflags_and_os_args()
 	foptions := FormatOptions{
 		is_c: '-c' in args
+		is_js: '-js' in args
 		is_l: '-l' in args
 		is_w: '-w' in args
 		is_diff: '-diff' in args
@@ -200,7 +202,7 @@ fn (foptions &FormatOptions) post_process_file(file string, formatted_file_path
 		return
 	}
 	is_formatted_different := fc != formatted_fc
-	if foptions.is_c {
+	if foptions.is_c || foptions.is_js {
 		if is_formatted_different {
 			eprintln('File is not formatted: $file')
 			exit(2)
diff --git a/cmd/v/v.v b/cmd/v/v.v
index 0e6a4e8f87..2455904fea 100644
--- a/cmd/v/v.v
+++ b/cmd/v/v.v
@@ -160,6 +160,13 @@ fn parse_args(args []string) (&pref.Preferences, string) {
 				res.out_name  = cmdline.option(args, '-o', '')
 				i++
 			}
+			'-b' {
+				b := pref.backend_from_string(cmdline.option(args, '-b', 'c')) or {
+					continue
+				}
+				res.backend = b
+				i++
+			}
 			else {
 				mut should_continue := false
 				for flag_with_param in list_of_flags_with_param {
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
index 0371d76dbc..32e816fd6c 100644
--- a/vlib/v/ast/ast.v
+++ b/vlib/v/ast/ast.v
@@ -56,6 +56,7 @@ pub:
 	val    string
 	is_raw bool
 	is_c   bool
+	is_js  bool
 	pos    token.Position
 }
 
@@ -146,6 +147,7 @@ pub:
 	pub_pos     int // pub:
 	pub_mut_pos int // pub mut:
 	is_c        bool
+	is_js       bool
 	is_union    bool
 }
 
@@ -187,6 +189,7 @@ pub:
 	is_method     bool
 	rec_mut       bool // is receiver mutable
 	is_c          bool
+	is_js		  bool
 	no_body       bool // just a definition `fn C.malloc()`
 	is_builtin    bool // this function is defined in builtin/strconv
 	pos           token.Position
@@ -208,6 +211,7 @@ mut:
 	args               []CallArg
 	expected_arg_types []table.Type
 	is_c               bool
+	is_js			   bool
 	or_block           OrExpr
 	left_type          table.Type // type of `user`
 	receiver_type      table.Type // User
@@ -301,6 +305,7 @@ pub struct Ident {
 pub:
 	value    string
 	is_c     bool
+	is_js    bool
 	tok_kind token.Kind
 	mod      string
 	pos      token.Position
diff --git a/vlib/v/ast/str.v b/vlib/v/ast/str.v
index 8503f723df..b984a474ac 100644
--- a/vlib/v/ast/str.v
+++ b/vlib/v/ast/str.v
@@ -36,6 +36,9 @@ pub fn (node &FnDecl) str(t &table.Table) string {
 	if node.is_c {
 		name = 'C.$name'
 	}
+	if node.is_js {
+		name = 'JS.$name'
+	}
 	f.write('fn ${receiver}${name}(')
 	for i, arg in node.args {
 		// skip receiver
diff --git a/vlib/v/builder/builder.v b/vlib/v/builder/builder.v
index 1b832e6ec1..d3dfc1c35c 100644
--- a/vlib/v/builder/builder.v
+++ b/vlib/v/builder/builder.v
@@ -12,6 +12,7 @@ import (
 	v.parser
 	v.scanner
 	v.gen
+	v.gen.js
 	v.gen.x64
 )
 
@@ -27,6 +28,7 @@ mut:
 	parsed_files        []ast.File
 	global_scope        &ast.Scope
 	out_name_c          string
+	out_name_js			string
 }
 
 pub fn new_builder(pref &pref.Preferences) Builder {
@@ -44,64 +46,6 @@ pub fn new_builder(pref &pref.Preferences) Builder {
 	}
 }
 
-pub fn (b mut Builder) gen_c(v_files []string) string {
-	t0 := time.ticks()
-	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
-	b.parse_imports()
-	t1 := time.ticks()
-	parse_time := t1 - t0
-	b.info('PARSE: ${parse_time}ms')
-	//
-	b.checker.check_files(b.parsed_files)
-	t2 := time.ticks()
-	check_time := t2 - t1
-	b.info('CHECK: ${check_time}ms')
-	if b.checker.nr_errors > 0 {
-		b.print_errors(b.checker.errors)
-		exit(1)
-	}
-	// println('starting cgen...')
-	res := gen.cgen(b.parsed_files, b.table, b.pref)
-	t3 := time.ticks()
-	gen_time := t3 - t2
-	b.info('C GEN: ${gen_time}ms')
-	// println('cgen done')
-	// println(res)
-	return res
-}
-
-pub fn (b mut Builder) build_c(v_files []string, out_file string) {
-	b.out_name_c = out_file
-	b.info('build_c($out_file)')
-	mut f := os.create(out_file) or {
-		panic(err)
-	}
-	f.writeln(b.gen_c(v_files))
-	f.close()
-	// os.write_file(out_file, b.gen_c(v_files))
-}
-
-pub fn (b mut Builder) build_x64(v_files []string, out_file string) {
-	$if !linux {
-		println('v -x64 can only generate Linux binaries for now')
-		println('You are not on a Linux system, so you will not ' + 'be able to run the resulting executable')
-	}
-	t0 := time.ticks()
-	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
-	b.parse_imports()
-	t1 := time.ticks()
-	parse_time := t1 - t0
-	b.info('PARSE: ${parse_time}ms')
-	b.checker.check_files(b.parsed_files)
-	t2 := time.ticks()
-	check_time := t2 - t1
-	b.info('CHECK: ${check_time}ms')
-	x64.gen(b.parsed_files, out_file)
-	t3 := time.ticks()
-	gen_time := t3 - t2
-	b.info('x64 GEN: ${gen_time}ms')
-}
-
 // parse all deps from already parsed files
 pub fn (b mut Builder) parse_imports() {
 	mut done_imports := []string
diff --git a/vlib/v/builder/c.v b/vlib/v/builder/c.v
new file mode 100644
index 0000000000..2f9a3181b6
--- /dev/null
+++ b/vlib/v/builder/c.v
@@ -0,0 +1,79 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+)
+
+pub fn (b mut Builder) gen_c(v_files []string) string {
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	//
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	if b.checker.nr_errors > 0 {
+		b.print_errors(b.checker.errors)
+		exit(1)
+	}
+	// println('starting cgen...')
+	// TODO: move gen.cgen() to c.gen()
+	res := gen.cgen(b.parsed_files, b.table, b.pref)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('C GEN: ${gen_time}ms')
+	// println('cgen done')
+	// println(res)
+	return res
+}
+
+pub fn (b mut Builder) build_c(v_files []string, out_file string) {
+	b.out_name_c = out_file
+	b.info('build_c($out_file)')
+	mut f := os.create(out_file) or {
+		panic(err)
+	}
+	f.writeln(b.gen_c(v_files))
+	f.close()
+	// os.write_file(out_file, b.gen_c(v_files))
+}
+
+pub fn (b mut Builder) compile_c(files []string, pref &pref.Preferences) {
+	if os.user_os() != 'windows' && pref.ccompiler == 'msvc' {
+		verror('Cannot build with msvc on ${os.user_os()}')
+	}
+	// cgen.genln('// Generated by V')
+	// println('compile2()')
+	if pref.is_verbose {
+		println('all .v files before:')
+		println(files)
+	}
+	// v1 compiler files
+	// v.add_v_files_to_compile()
+	// v.files << v.dir
+	// v2 compiler
+	// b.set_module_lookup_paths()
+	files << b.get_builtin_files()
+	files << b.get_user_files()
+	b.set_module_lookup_paths()
+	if pref.is_verbose {
+		println('all .v files:')
+		println(files)
+	}
+	mut out_name_c := get_vtmp_filename(pref.out_name, '.tmp.c')
+	if pref.is_so {
+		out_name_c = get_vtmp_filename(pref.out_name, '.tmp.so.c')
+	}
+	b.build_c(files, out_name_c)
+	b.cc()
+}
+
+
diff --git a/vlib/v/builder/compile.v b/vlib/v/builder/compile.v
index 5130718f7b..ac53cc6fc3 100644
--- a/vlib/v/builder/compile.v
+++ b/vlib/v/builder/compile.v
@@ -35,39 +35,14 @@ pub fn compile(command string, pref &pref.Preferences) {
 	}
 	mut tmark := benchmark.new_benchmark()
 	mut files := []string
-	if pref.backend == .x64 {
-		// v.files << v.v_files_from_dir(os.join_path(v.pref.vlib_path,'builtin','bare'))
-		files << pref.path
-		b.set_module_lookup_paths()
-		b.build_x64(files, pref.out_name)
-	} else {
-		if os.user_os() != 'windows' && pref.ccompiler == 'msvc' {
-			verror('Cannot build with msvc on ${os.user_os()}')
+	match pref.backend {
+		.c { b.compile_c(files, pref) }
+		.js { b.compile_js(files, pref) }
+		.x64 { b.compile_x64(files, pref) }
+		else {
+			eprintln('backend not implemented `$pref.backend`')
+			exit(1)
 		}
-		// cgen.genln('// Generated by V')
-		// println('compile2()')
-		if pref.is_verbose {
-			println('all .v files before:')
-			println(files)
-		}
-		// v1 compiler files
-		// v.add_v_files_to_compile()
-		// v.files << v.dir
-		// v2 compiler
-		// b.set_module_lookup_paths()
-		files << b.get_builtin_files()
-		files << b.get_user_files()
-		b.set_module_lookup_paths()
-		if pref.is_verbose {
-			println('all .v files:')
-			println(files)
-		}
-		mut out_name_c := get_vtmp_filename(pref.out_name, '.tmp.c')
-		if pref.is_so {
-			out_name_c = get_vtmp_filename(pref.out_name, '.tmp.so.c')
-		}
-		b.build_c(files, out_name_c)
-		b.cc()
 	}
 	if pref.is_stats {
 		tmark.stop()
diff --git a/vlib/v/builder/js.v b/vlib/v/builder/js.v
new file mode 100644
index 0000000000..1965051556
--- /dev/null
+++ b/vlib/v/builder/js.v
@@ -0,0 +1,53 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+	v.gen.js
+)
+
+pub fn (b mut Builder) gen_js(v_files []string) string {
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	if b.checker.nr_errors > 0 {
+		exit(1)
+	}
+	res := js.gen(b.parsed_files, b.table, b.pref)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('JS GEN: ${gen_time}ms')
+	return res
+}
+
+pub fn (b mut Builder) build_js(v_files []string, out_file string) {
+	b.out_name_js = out_file
+	b.info('build_js($out_file)')
+	mut f := os.create(out_file) or {
+		panic(err)
+	}
+	f.writeln(b.gen_js(v_files))
+	f.close()
+}
+
+pub fn (b mut Builder) compile_js(files []string, pref &pref.Preferences) {
+	//TODO files << b.get_builtin_files()
+	files << b.get_user_files()
+	b.set_module_lookup_paths()
+	if pref.is_verbose {
+		println('all .v files:')
+		println(files)
+	}
+	b.build_js(files, pref.out_name + '.js')
+	//TODO run the file
+}
diff --git a/vlib/v/builder/x64.v b/vlib/v/builder/x64.v
new file mode 100644
index 0000000000..b1caff4c07
--- /dev/null
+++ b/vlib/v/builder/x64.v
@@ -0,0 +1,38 @@
+module builder
+
+import (
+	time
+	os
+	v.parser
+	v.pref
+	v.gen
+	v.gen.x64
+)
+
+pub fn (b mut Builder) build_x64(v_files []string, out_file string) {
+	$if !linux {
+		println('v -x64 can only generate Linux binaries for now')
+		println('You are not on a Linux system, so you will not ' + 'be able to run the resulting executable')
+	}
+	t0 := time.ticks()
+	b.parsed_files = parser.parse_files(v_files, b.table, b.pref, b.global_scope)
+	b.parse_imports()
+	t1 := time.ticks()
+	parse_time := t1 - t0
+	b.info('PARSE: ${parse_time}ms')
+	b.checker.check_files(b.parsed_files)
+	t2 := time.ticks()
+	check_time := t2 - t1
+	b.info('CHECK: ${check_time}ms')
+	x64.gen(b.parsed_files, out_file)
+	t3 := time.ticks()
+	gen_time := t3 - t2
+	b.info('x64 GEN: ${gen_time}ms')
+}
+
+pub fn (b mut Builder) compile_x64(files []string, pref &pref.Preferences) {
+	// v.files << v.v_files_from_dir(os.join_path(v.pref.vlib_path,'builtin','bare'))
+	files << pref.path
+	b.set_module_lookup_paths()
+	b.build_x64(files, pref.out_name)	
+}
\ No newline at end of file
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
index 45f6eebf8f..dcff2b254b 100644
--- a/vlib/v/checker/checker.v
+++ b/vlib/v/checker/checker.v
@@ -413,7 +413,7 @@ pub fn (c mut Checker) call_fn(call_expr mut ast.CallExpr) table.Type {
 		return table.void_type
 	}
 	call_expr.return_type = f.return_type
-	if f.is_c || call_expr.is_c {
+	if f.is_c || call_expr.is_c || f.is_js || call_expr.is_js {
 		for arg in call_expr.args {
 			c.expr(arg.expr)
 		}
@@ -922,7 +922,7 @@ fn (c mut Checker) stmt(node ast.Stmt) {
 			c.expected_type = table.void_type
 			c.fn_return_type = it.return_type
 			c.stmts(it.stmts)
-			if !it.is_c && !it.no_body && it.return_type != table.void_type && !c.returns &&
+			if !it.is_c && !it.is_js && !it.no_body && it.return_type != table.void_type && !c.returns &&
 				!(it.name in ['panic', 'exit']) {
 				c.error('missing return at end of function `$it.name`', it.pos)
 			}
diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v
index b40389b787..bcb72c57e5 100644
--- a/vlib/v/fmt/fmt.v
+++ b/vlib/v/fmt/fmt.v
@@ -256,7 +256,7 @@ fn (f mut Fmt) stmt(node ast.Stmt) {
 			s := it.str(f.table)
 			// f.write(it.str(f.table))
 			f.write(s.replace(f.cur_mod + '.', ''))			// `Expr` instead of `ast.Expr` in mod ast
-			if !it.is_c {
+			if !it.is_c && !it.is_js {
 				f.writeln(' {')
 				f.stmts(it.stmts)
 				f.writeln('}\n')
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
new file mode 100644
index 0000000000..1d82d54780
--- /dev/null
+++ b/vlib/v/gen/js/js.v
@@ -0,0 +1,1064 @@
+module js
+
+import (
+	strings
+	v.ast
+	v.table
+	v.depgraph
+	v.token
+	v.pref
+	term
+	v.util
+)
+
+const (
+	//TODO
+	js_reserved = ['delete', 'const', 'let', 'var', 'function', 'continue', 'break', 'switch', 'for', 'in', 'of', 'instanceof', 'typeof', 'do']
+	tabs = ['', '\t', '\t\t', '\t\t\t', '\t\t\t\t', '\t\t\t\t\t', '\t\t\t\t\t\t', '\t\t\t\t\t\t\t', '\t\t\t\t\t\t\t\t']
+)
+
+struct JsGen {
+	out   			strings.Builder
+	namespaces		map[string]strings.Builder
+	namespaces_pub	map[string][]string
+	namespace 		string
+	table 			&table.Table
+	definitions 	strings.Builder
+	pref            &pref.Preferences
+	doc				&JsDoc
+	mut:
+	constants		strings.Builder // all global V constants 
+	file			ast.File
+	tmp_count		int
+	inside_ternary  bool
+	inside_loop		bool
+	is_test         bool
+	indents			map[string]int // indentations mapped to namespaces
+	stmt_start_pos	int
+	defer_stmts     []ast.DeferStmt
+	fn_decl			&ast.FnDecl // pointer to the FnDecl we are currently inside otherwise 0
+	str_types		[]string // types that need automatic str() generation
+	method_fn_decls map[string][]ast.Stmt
+	empty_line		bool
+}
+
+pub fn gen(files []ast.File, table &table.Table, pref &pref.Preferences) string {
+	mut g := &JsGen{
+		out: strings.new_builder(100)
+		definitions: strings.new_builder(100)
+		constants: strings.new_builder(100)
+		table: table
+		pref: pref
+		fn_decl: 0
+		empty_line: true
+		doc: 0
+	}
+	g.doc = new_jsdoc(g)
+	g.init()
+
+	// Get class methods
+	for file in files {
+		g.file = file
+		g.enter_namespace(g.file.mod.name)
+		g.is_test = g.file.path.ends_with('_test.v')
+		g.find_class_methods(file.stmts)
+		g.escape_namespace()
+	}
+
+	for file in files {
+		g.file = file
+		g.enter_namespace(g.file.mod.name)
+		g.is_test = g.file.path.ends_with('_test.v')
+		g.stmts(file.stmts)
+		// store the current namespace
+		g.escape_namespace()
+	}
+	g.finish()
+	mut out := g.hashes() + g.definitions.str() + g.constants.str()
+	for key in g.namespaces.keys() {
+		out += '/* namespace: $key */\n'
+		// private scope
+		out += g.namespaces[key].str()
+		// public scope
+		out += '\n\t/* module exports */'
+		out += '\n\treturn {'
+		for pub_var in g.namespaces_pub[key] {
+			out += '\n\t\t$pub_var,'
+		}
+		out += '\n\t};'
+		out += '\n})();'
+	}
+	return out
+}
+
+pub fn (g mut JsGen) enter_namespace(n string) {
+	g.namespace = n
+	if g.namespaces[g.namespace].len == 0 {
+		// create a new namespace
+		g.out = strings.new_builder(100)
+		g.indents[g.namespace] = 0
+		g.out.writeln('const $n = (function () {')
+	} else {
+		g.out = g.namespaces[g.namespace]
+	}
+}
+
+pub fn (g mut JsGen) escape_namespace() {
+	g.namespaces[g.namespace] = g.out
+	g.namespace = ""
+}
+
+pub fn (g mut JsGen) push_pub_var(s string) {
+	// Workaround until `m[key]<<val` works.
+	arr := g.namespaces_pub[g.namespace]
+	arr << s
+	g.namespaces_pub[g.namespace] = arr
+}
+
+pub fn (g mut JsGen) find_class_methods(stmts []ast.Stmt) {
+	for stmt in stmts {
+		match stmt {
+			ast.FnDecl {
+				if it.is_method {
+					// Found struct method, store it to be generated along with the class.
+					class_name :=  g.table.get_type_symbol(it.receiver.typ).name
+					// Workaround until `map[key] << val` works.
+					arr := g.method_fn_decls[class_name]
+					arr << stmt
+					g.method_fn_decls[class_name] = arr
+				}
+			}
+			else {}
+		}
+	}
+}
+
+pub fn (g mut JsGen) init() {
+	g.definitions.writeln('// Generated by the V compiler')
+	g.definitions.writeln('"use strict";')
+	g.definitions.writeln('')
+}
+
+pub fn (g mut JsGen) finish() {
+	if g.constants.len > 0 {
+		constants := g.constants.str()
+		g.constants = strings.new_builder(100)
+		g.constants.writeln('const CONSTANTS = Object.freeze({')
+		g.constants.write(constants)
+		g.constants.writeln('});')
+		g.constants.writeln('')
+	}
+}
+
+pub fn (g JsGen) hashes() string {
+	mut res := '// V_COMMIT_HASH ${util.vhash()}\n'
+	res += '// V_CURRENT_COMMIT_HASH ${util.githash(g.pref.building_v)}\n\n'
+	return res
+}
+
+
+// V type to JS type
+pub fn (g mut JsGen) typ(t table.Type) string {
+	sym := g.table.get_type_symbol(t)
+	mut styp := sym.name.replace('.', '__')
+	if styp.starts_with('JS__') {
+		styp = styp[4..]
+	}
+	return g.to_js_typ(styp)
+}
+
+fn (g mut JsGen) to_js_typ(typ string) string {
+	mut styp := ''
+	match typ {
+		'int' {
+			styp = 'number'
+		}
+		'bool' {
+			styp = 'boolean'
+		}
+		'voidptr' {
+			styp = 'Object'
+		} 
+		'byteptr' {
+			styp = 'string'
+		}
+		'charptr' {
+			styp = 'string'
+		} else {
+			if typ.starts_with('array_') {
+				styp = g.to_js_typ(typ.replace('array_', '')) + '[]'
+			} else if typ.starts_with('map_') {
+				tokens := typ.split('_')
+				styp = 'Map<${tokens[1]}, ${tokens[2]}>'
+			} else {
+				styp = typ
+			}
+		}
+	}
+	return styp
+} 
+
+pub fn (g &JsGen) save() {}
+
+pub fn (g mut JsGen) gen_indent() {
+	if g.indents[g.namespace] > 0 && g.empty_line {
+		g.out.write(tabs[g.indents[g.namespace]])
+	}
+	g.empty_line = false
+}
+
+pub fn (g mut JsGen) inc_indent() {
+	g.indents[g.namespace] = g.indents[g.namespace] + 1
+}
+
+pub fn (g mut JsGen) dec_indent() {
+	g.indents[g.namespace] = g.indents[g.namespace] - 1
+}
+
+pub fn (g mut JsGen) write(s string) {
+	g.gen_indent()
+	g.out.write(s)
+}
+
+pub fn (g mut JsGen) writeln(s string) {
+	g.gen_indent()
+	g.out.writeln(s)
+	g.empty_line = true
+}
+
+pub fn (g mut JsGen) new_tmp_var() string {
+	g.tmp_count++
+	return 'tmp$g.tmp_count'
+}
+
+fn (g mut JsGen) stmts(stmts []ast.Stmt) {
+	g.inc_indent()
+	for stmt in stmts {
+		g.stmt(stmt)
+	}
+	g.dec_indent()
+}
+
+fn (g mut JsGen) stmt(node ast.Stmt) {
+	g.stmt_start_pos = g.out.len
+
+	match node {
+		ast.Module {
+			// TODO: Implement namespaces
+		}
+		ast.AssertStmt {
+			g.gen_assert_stmt(it)
+		}
+		ast.AssignStmt {
+			g.gen_assign_stmt(it)
+		}
+		ast.Attr {
+			g.gen_attr(it)
+		}
+		ast.Block {
+			g.gen_block(it)
+			g.writeln('')
+		}
+		ast.BranchStmt {
+			g.gen_branch_stmt(it)
+		}
+		ast.ConstDecl {
+			g.gen_const_decl(it)
+		}
+		ast.CompIf {
+			// skip: JS has no compile time if
+		}
+		ast.DeferStmt {
+			g.defer_stmts << *it
+		}
+		ast.EnumDecl {
+			g.gen_enum_decl(it)
+			g.writeln('')
+		}
+		ast.ExprStmt {
+			g.gen_expr_stmt(it)
+		}
+		ast.FnDecl {
+			g.fn_decl = it
+			g.gen_fn_decl(it)
+			g.writeln('')
+		}
+		ast.ForCStmt {
+			g.gen_for_c_stmt(it)
+			g.writeln('')
+		}
+		ast.ForInStmt {
+			g.gen_for_in_stmt(it)
+			g.writeln('')
+		}
+		ast.ForStmt {
+			g.gen_for_stmt(it)
+			g.writeln('')
+		}
+		ast.GoStmt {
+			g.gen_go_stmt(it)
+			g.writeln('')
+		}
+		ast.GotoLabel {
+			g.writeln('$it.name:')
+		}
+		ast.GotoStmt {
+			// skip: JS has no goto
+		}
+		ast.HashStmt {
+			// skip: nothing with # in JS
+		}
+		ast.Import {}
+		ast.InterfaceDecl {
+			// TODO skip: interfaces not implemented yet
+		}
+		ast.Return {
+			if g.defer_stmts.len > 0 {
+				g.gen_defer_stmts()
+			}
+			g.gen_return_stmt(it)
+		}
+		ast.StructDecl {
+			g.gen_struct_decl(it)
+		}
+		ast.TypeDecl {
+			// skip JS has no typedecl
+		}
+		ast.UnsafeStmt {
+			g.stmts(it.stmts)
+		}
+		else {
+			verror('jsgen.stmt(): bad node ${typeof(node)}')
+		}
+	}
+}
+
+fn (g mut JsGen) expr(node ast.Expr) {
+	match node {
+		ast.ArrayInit {
+			g.gen_array_init_expr(it)
+		}
+		ast.BoolLiteral {
+			if it.val == true {
+				g.write('true')
+			}
+			else {
+				g.write('false')
+			}
+		}
+		ast.CharLiteral {
+			g.write("'$it.val'")
+		}
+		ast.CallExpr {
+			g.expr(it.left)
+			if it.is_method {
+				// example: foo.bar.baz()
+				g.write('.')
+			}
+			g.write('${it.name}(')
+			for i, arg in it.args {
+				g.expr(arg.expr)
+				if i != it.args.len - 1 {
+					g.write(', ')
+				}
+			}
+			g.write(')')
+		}
+		ast.EnumVal {
+			styp := g.typ(it.typ)
+			g.write('${styp}.${it.val}')
+		}
+		ast.FloatLiteral {
+			g.write(it.val)
+		}
+		ast.Ident {
+			g.gen_ident(it)
+		}
+		ast.IfExpr {
+			g.gen_if_expr(it)
+		}
+		ast.IfGuardExpr {
+			// TODO no optionals yet
+		}
+		ast.IntegerLiteral {
+			g.write(it.val)
+		}
+		ast.InfixExpr {
+			g.expr(it.left)
+			
+			mut op := it.op.str()
+			// in js == is non-strict & === is strict, always do strict
+			if op == '==' { op = '===' }
+			else if op == '!=' { op = '!==' }
+			
+			g.write(' $op ')
+			g.expr(it.right)
+		}
+		ast.MapInit {
+			g.gen_map_init_expr(it)
+		}
+		/*
+		ast.UnaryExpr {
+			g.expr(it.left)
+			g.write(' $it.op ')
+		}
+		*/
+
+		ast.StringLiteral {
+			g.write('"$it.val"')
+		}
+		ast.StringInterLiteral {
+			g.gen_string_inter_literal(it)
+		}
+		ast.PostfixExpr {
+			g.expr(it.expr)
+			g.write(it.op.str())
+		}
+		ast.StructInit {
+			// `user := User{name: 'Bob'}`
+			g.gen_struct_init(it)
+		}
+		ast.SelectorExpr {
+			g.gen_selector_expr(it)
+		}
+		else {
+			println(term.red('jsgen.expr(): bad node'))
+		}
+	}
+}
+
+fn (g mut JsGen) gen_string_inter_literal(it ast.StringInterLiteral) {
+	g.write('tos3(`')
+	for i, val in it.vals {
+		escaped_val := val.replace_each(['`', '\`', '\r\n', '\n'])
+		g.write(escaped_val)
+		if i >= it.exprs.len {
+			continue
+		}
+		expr := it.exprs[i]
+		sfmt := it.expr_fmts[i]
+		g.write('\${')
+		if sfmt.len > 0 {
+			fspec := sfmt[sfmt.len - 1]
+			if fspec == `s` && it.expr_types[i] == table.string_type {
+				g.expr(expr)
+				g.write('.str')
+			} else {
+				g.expr(expr)
+			}
+		} else if it.expr_types[i] == table.string_type {
+			// `name.str`
+			g.expr(expr)
+			g.write('.str')
+		} else if it.expr_types[i] == table.bool_type {
+			// `expr ? "true" : "false"`
+			g.expr(expr)
+			g.write(' ? "true" : "false"')
+		}  else {
+			sym := g.table.get_type_symbol(it.expr_types[i])
+
+			match sym.kind {
+				.struct_ {
+					g.expr(expr)
+					if sym.has_method('str') {
+						g.write('.str()')					
+					}
+				}
+				else {
+					g.expr(expr)
+				}
+			}
+		}
+		g.write('}')
+	}
+	g.write('`)')
+}
+
+fn (g mut JsGen) gen_array_init_expr(it ast.ArrayInit) {
+	type_sym := g.table.get_type_symbol(it.typ)
+	if type_sym.kind != .array_fixed {
+		g.write('[')
+		for i, expr in it.exprs {
+			g.expr(expr)
+			if i < it.exprs.len - 1 {
+				g.write(', ')
+			}
+		}
+		g.write(']')
+	} else {}
+}
+
+fn (g mut JsGen) gen_assert_stmt(a ast.AssertStmt) {
+	g.writeln('// assert')
+	g.write('if( ')
+	g.expr(a.expr)
+	g.write(' ) {')
+	s_assertion := a.expr.str().replace('"', "\'")
+	mut mod_path := g.file.path
+	if g.is_test {
+		g.writeln('	g_test_oks++;')
+		g.writeln('	cb_assertion_ok("${mod_path}", ${a.pos.line_nr+1}, "assert ${s_assertion}", "${g.fn_decl.name}()" );')
+		g.writeln('} else {')
+		g.writeln('	g_test_fails++;')
+		g.writeln('	cb_assertion_failed("${mod_path}", ${a.pos.line_nr+1}, "assert ${s_assertion}", "${g.fn_decl.name}()" );')
+		g.writeln('	exit(1);')
+		g.writeln('}')
+		return
+	}
+	g.writeln('} else {')
+	g.writeln('	eprintln("${mod_path}:${a.pos.line_nr+1}: FAIL: fn ${g.fn_decl.name}(): assert $s_assertion");')
+	g.writeln('	exit(1);')
+	g.writeln('}')
+}
+
+fn (g mut JsGen) gen_assign_stmt(it ast.AssignStmt) {
+	if it.left.len > it.right.len {
+		// multi return
+		jsdoc := strings.new_builder(50)
+		jsdoc.write('[')
+		stmt := strings.new_builder(50)
+		stmt.write('const [')
+		for i, ident in it.left {
+			ident_var_info := ident.var_info()
+			styp := g.typ(ident_var_info.typ)
+			jsdoc.write(styp)
+
+			stmt.write('$ident.name')
+
+			if i < it.left.len - 1 {
+				jsdoc.write(', ')
+				stmt.write(', ')
+			}
+		}
+		jsdoc.write(']')
+		stmt.write('] = ')
+		g.writeln(g.doc.gen_typ(jsdoc.str(), ''))
+		g.write(stmt.str())
+		g.expr(it.right[0])
+		g.writeln(';')
+	}
+	else {
+		// `a := 1` | `a,b := 1,2`
+		for i, ident in it.left {
+			val := it.right[i]
+			ident_var_info := ident.var_info()
+			mut styp := g.typ(ident_var_info.typ)
+		
+			match val {
+				ast.EnumVal {
+					// we want the type of the enum value not the enum
+					styp = 'number'
+				}
+				ast.StructInit {
+					// no need to print jsdoc for structs
+					styp = ''
+				} else {}
+			}
+			
+			if !g.inside_loop && styp.len > 0 {
+				g.writeln(g.doc.gen_typ(styp, ident.name))
+			}
+			
+			if g.inside_loop || ident.is_mut {
+				g.write('let ')
+			} else {
+				g.write('const ')
+			}
+
+			g.write('$ident.name = ')
+			g.expr(val)
+
+			if g.inside_loop {
+				g.write("; ")
+			} else {
+				g.writeln(';')
+			}
+		}
+	}
+}
+
+fn (g mut JsGen) gen_attr(it ast.Attr) {
+	g.writeln('/* [$it.name] */')
+}
+
+fn (g mut JsGen) gen_block(it ast.Block) {
+	g.writeln('{')
+	g.stmts(it.stmts)
+	g.writeln('}')
+}
+
+fn (g mut JsGen) gen_branch_stmt(it ast.BranchStmt) {
+	// continue or break
+	g.write(it.tok.kind.str())
+	g.writeln(';')
+}
+
+fn (g mut JsGen) gen_const_decl(it ast.ConstDecl) {
+	old_indent := g.indents[g.namespace]
+	for i, field in it.fields {
+		// TODO hack. Cut the generated value and paste it into definitions.
+		pos := g.out.len
+		g.expr(field.expr)
+		val := g.out.after(pos)
+		g.out.go_back(val.len)
+		typ := g.typ(field.typ)
+		g.constants.write('\t')
+		g.constants.writeln(g.doc.gen_typ(typ, field.name))
+		g.constants.write('\t')
+		g.constants.write('$field.name: $val')
+		if i < it.fields.len - 1 {
+			g.constants.writeln(',')
+		}
+	}
+	g.constants.writeln('')
+}
+
+fn (g mut JsGen) gen_defer_stmts() {
+	g.writeln('(function defer() {')
+	for defer_stmt in g.defer_stmts {
+		g.stmts(defer_stmt.stmts)
+	}
+	g.writeln('})();')
+}
+
+fn (g mut JsGen) gen_enum_decl(it ast.EnumDecl) {
+	g.writeln('const $it.name = Object.freeze({')
+	g.inc_indent()
+	for i, field in it.fields {
+		g.write('$field.name: ')
+		if field.has_expr {
+			pos := g.out.len
+			g.expr(field.expr)
+			expr_str := g.out.after(pos)
+			g.out.go_back(expr_str.len)
+			g.write('$expr_str')
+		} else {
+			g.write('$i')
+		}
+		g.writeln(',')
+	}
+	g.dec_indent()
+	g.writeln('});')
+	if it.is_pub {
+		g.push_pub_var(it.name)
+	}
+}
+
+fn (g mut JsGen) gen_expr_stmt(it ast.ExprStmt) {
+	g.expr(it.expr)
+	expr := it.expr
+	match expr {
+		ast.IfExpr {
+			// no ; after an if expression
+		}
+		else {
+			if !g.inside_ternary {
+				g.writeln(';')
+			}
+		}
+	}
+}
+
+fn (g mut JsGen) gen_fn_decl(it ast.FnDecl) {
+	if it.is_method {
+		// Struct methods are handled by class generation code.
+		return
+	}
+	if it.no_body {
+		return
+	}
+	g.gen_method_decl(it)
+}
+
+fn (g mut JsGen) gen_method_decl(it ast.FnDecl) {
+	g.fn_decl = &it
+	has_go := fn_has_go(it)
+	is_main := it.name == 'main'
+	if is_main {
+		// there is no concept of main in JS but we do have iife
+		g.writeln('/* program entry point */')
+		g.write('(')
+		if has_go {
+			g.write('async ')
+		}
+		g.write('function(')
+	} else {
+		mut name := it.name
+		c := name[0]
+		if c in [`+`, `-`, `*`, `/`] {
+			name = util.replace_op(name)
+		}
+
+		type_name := g.typ(it.return_type)
+
+		// generate jsdoc for the function
+		g.writeln(g.doc.gen_fn(it))
+
+		if has_go {
+			g.write('async ')
+		}
+		if !it.is_method {
+			g.write('function ')
+		}
+		g.write('${name}(')
+
+		if it.is_pub {
+			g.push_pub_var(name)
+		}
+	}
+
+	mut args := it.args
+	if it.is_method {
+		args = args[1..]
+	}
+	g.fn_args(args, it.is_variadic)
+	g.writeln(') {')
+
+	if it.is_method {
+		g.inc_indent()
+		g.writeln('const ${it.args[0].name} = this;')
+		g.dec_indent()
+	}
+
+	g.stmts(it.stmts)
+	g.write('}')
+	if is_main {
+		g.write(')();')
+	}
+	g.writeln('')
+	
+	g.fn_decl = 0
+}
+
+fn (g mut JsGen) gen_for_c_stmt(it ast.ForCStmt) {
+	g.inside_loop = true
+	g.write('for (')
+	if it.has_init {
+		g.stmt(it.init)
+	} else {
+		g.write('; ')
+	}
+	if it.has_cond {
+		g.expr(it.cond)
+	}
+	g.write('; ')
+	if it.has_inc {
+		g.expr(it.inc)
+	}
+	g.writeln(') {')
+	g.stmts(it.stmts)
+	g.writeln('}')
+	g.inside_loop = false
+}
+
+fn (g mut JsGen) gen_for_in_stmt(it ast.ForInStmt) {
+	if it.is_range {
+		// `for x in 1..10 {`
+		i := it.val_var
+		g.inside_loop = true
+		g.write('for (let $i = ')
+		g.expr(it.cond)
+		g.write('; $i < ')
+		g.expr(it.high)
+		g.writeln('; ++$i) {')
+		g.inside_loop = false
+		g.stmts(it.stmts)
+		g.writeln('}')
+	} else if it.kind == .array || table.type_is(it.cond_type, .variadic) {
+		// `for num in nums {`
+		i := if it.key_var == '' { g.new_tmp_var() } else { it.key_var }
+		styp := g.typ(it.val_type)
+		g.inside_loop = true
+		g.write('for (let $i = 0; $i < ')
+		g.expr(it.cond)
+		g.writeln('.length; ++$i) {')
+		g.inside_loop = false
+		g.write('\tlet $it.val_var = ')
+		g.expr(it.cond)
+		g.writeln('[$i];')
+		g.stmts(it.stmts)
+		g.writeln('}')
+	} else if it.kind == .map {
+		// `for key, val in map[string]int {`
+		key_styp := g.typ(it.key_type)
+		val_styp := g.typ(it.val_type)
+		key := if it.key_var == '' { g.new_tmp_var() } else { it.key_var }
+		g.write('for (let [$key, $it.val_var] of ')
+		g.expr(it.cond)
+		g.writeln(') {')
+		g.stmts(it.stmts)
+		g.writeln('}')
+	} else if it.kind == .string {
+		// `for x in 'hello' {`
+		i := if it.key_var == '' { g.new_tmp_var() } else { it.key_var }
+		g.inside_loop = true
+		g.write('for (let $i = 0; $i < ')
+		g.expr(it.cond)
+		g.writeln('.length; ++$i) {')
+		g.inside_loop = false
+		g.write('\tlet $it.val_var = ')
+		g.expr(it.cond)
+		g.writeln('[$i];')
+		g.stmts(it.stmts)
+		g.writeln('}')
+	}
+}
+
+fn (g mut JsGen) gen_for_stmt(it ast.ForStmt) {
+	g.write('while (')
+	if it.is_inf {
+		g.write('true')
+	} else {
+		g.expr(it.cond)
+	}
+	g.writeln(') {')
+	g.stmts(it.stmts)
+	g.writeln('}')
+}
+
+fn (g mut JsGen) fn_args(args []table.Arg, is_variadic bool) {
+	no_names := args.len > 0 && args[0].name == 'arg_1'
+	for i, arg in args {
+		is_varg := i == args.len - 1 && is_variadic
+		if is_varg {
+			g.write('...$arg.name')
+		} else {
+			g.write(arg.name)
+		}
+		// if its not the last argument
+		if i < args.len - 1 {
+			g.write(', ')
+		}
+	}
+}
+
+fn (g mut JsGen) gen_go_stmt(node ast.GoStmt) {
+	// x := node.call_expr as ast.CallEpxr // TODO
+	match node.call_expr {
+		ast.CallExpr { 
+			mut name := it.name
+			if it.is_method {
+				receiver_sym := g.table.get_type_symbol(it.receiver_type)
+				name = receiver_sym.name + '.' + name
+			}
+			g.writeln('await new Promise(function(resolve){')
+			g.inc_indent()
+			g.write('${name}(')
+			for i, arg in it.args {
+				g.expr(arg.expr)
+				if i < it.args.len - 1 {
+					g.write(', ')
+				}
+			}
+			g.writeln(');')
+			g.writeln('resolve();')
+			g.dec_indent()
+			g.writeln('});')
+		}
+		else { }
+	}
+}
+
+fn (g mut JsGen) gen_map_init_expr(it ast.MapInit) {
+	key_typ_sym := g.table.get_type_symbol(it.key_type)
+	value_typ_sym := g.table.get_type_symbol(it.value_type)
+	key_typ_str := key_typ_sym.name.replace('.', '__')
+	value_typ_str := value_typ_sym.name.replace('.', '__')
+	if it.vals.len > 0 {
+		g.writeln('new Map([')
+		g.inc_indent()
+		for i, key in it.keys {
+			val := it.vals[i]
+			g.write('[')
+			g.expr(key)
+			g.write(', ')
+			g.expr(val)
+			g.write(']')
+			if i < it.keys.len - 1 {
+				g.write(',')
+			}
+			g.writeln('')
+		}
+		g.dec_indent()
+		g.write('])')
+	} else {
+		g.write('new Map()')
+	}
+}
+
+fn (g mut JsGen) gen_return_stmt(it ast.Return) {
+	g.write('return ')
+
+	if g.fn_decl.name == 'main' {
+		// we can't return anything in main
+		g.writeln('void;')
+		return
+	}
+
+	// multiple returns
+	if it.exprs.len > 1 {
+		g.write('[')
+		for i, expr in it.exprs {
+			g.expr(expr)
+			if i < it.exprs.len - 1 {
+				g.write(', ')
+			}
+		}
+		g.write(']')
+	}
+	else {
+		g.expr(it.exprs[0])
+	}
+	g.writeln(';')
+}
+
+
+fn (g mut JsGen) enum_expr(node ast.Expr) {
+	match node {
+		ast.EnumVal {
+			g.write(it.val)
+		}
+		else {
+			g.expr(node)
+		}
+	}
+}
+
+fn (g mut JsGen) gen_struct_decl(node ast.StructDecl) {
+  	g.writeln('class $node.name {')
+	g.inc_indent()
+	g.writeln(g.doc.gen_ctor(node.fields))
+	g.writeln('constructor(values) {')
+	g.inc_indent()
+	for field in node.fields {
+    	g.writeln('this.$field.name = values.$field.name')
+	}
+	g.dec_indent()
+	g.writeln('}')
+	g.writeln('')
+
+	fns := g.method_fn_decls[node.name]
+	for cfn in fns {
+		// TODO: Fix this hack for type conversion
+		// Directly converting to FnDecl gives
+		// error: conversion to non-scalar type requested
+		match cfn {
+			ast.FnDecl {
+				g.gen_method_decl(it)
+			}
+			else {}
+		}
+
+	}
+
+	g.dec_indent()
+	g.writeln('}')
+
+	if node.is_pub {
+		g.push_pub_var(node.name)
+	}
+}
+
+fn (g mut JsGen) gen_struct_init(it ast.StructInit) {
+	type_sym := g.table.get_type_symbol(it.typ)
+	g.writeln('new ${type_sym.name}({')
+	g.inc_indent()
+	for i, field in it.fields {
+		g.write('$field: ')
+		g.expr(it.exprs[i])
+		if i < it.fields.len - 1 {
+			g.write(', ')				
+		}
+		g.writeln('')
+	}
+	g.dec_indent()
+	g.write('})')
+}
+
+fn (g mut JsGen) gen_ident(node ast.Ident) {	
+	if node.kind == .constant {
+		g.write('CONSTANTS.')
+	}
+
+	// TODO js_name
+	name := node.name
+	// TODO `is`
+	// TODO handle optionals
+	g.write(name)
+}
+
+fn (g mut JsGen) gen_selector_expr(it ast.SelectorExpr) {
+	g.expr(it.expr)
+	g.write('.$it.field')
+}
+
+fn (g mut JsGen) gen_if_expr(node ast.IfExpr) {
+	type_sym := g.table.get_type_symbol(node.typ)
+
+	// one line ?:
+	if node.is_expr && node.branches.len >= 2 && node.has_else && type_sym.kind != .void {
+		// `x := if a > b {  } else if { } else { }`
+		g.write('(')
+		g.inside_ternary = true
+		for i, branch in node.branches {
+			if i > 0 {
+				g.write(' : ')
+			}
+			if i < node.branches.len - 1 || !node.has_else {
+				g.expr(branch.cond)
+				g.write(' ? ')
+			}
+			g.stmts(branch.stmts)
+		}
+		g.inside_ternary = false
+		g.write(')')
+	} else {
+		//mut is_guard = false
+		for i, branch in node.branches {
+			if i == 0 {
+				match branch.cond {
+					ast.IfGuardExpr {
+						// TODO optionals
+					}
+					else {
+						g.write('if (')
+						g.expr(branch.cond)
+						g.writeln(') {')
+					}
+				}
+			} else if i < node.branches.len - 1 || !node.has_else {
+				g.write('} else if (')
+				g.expr(branch.cond)
+				g.writeln(') {')
+			} else if i == node.branches.len - 1 && node.has_else {
+				/* if is_guard {
+					//g.writeln('} if (!$guard_ok) { /* else */')
+				} else { */
+				g.writeln('} else {')
+				//}
+			}
+			g.stmts(branch.stmts)
+		}
+		/* if is_guard {
+			g.write('}')
+		} */
+		g.writeln('}')
+		g.writeln('')
+	}
+}
+
+fn verror(s string) {
+	util.verror('jsgen error', s)
+}
+
+fn fn_has_go(it ast.FnDecl) bool {
+	mut has_go := false
+	for stmt in it.stmts {
+		match stmt {
+			ast.GoStmt {
+				has_go = true
+			} else {}
+		}
+	}
+	return has_go
+}
\ No newline at end of file
diff --git a/vlib/v/gen/js/jsdoc.v b/vlib/v/gen/js/jsdoc.v
new file mode 100644
index 0000000000..45a3743d58
--- /dev/null
+++ b/vlib/v/gen/js/jsdoc.v
@@ -0,0 +1,87 @@
+module js
+
+import (
+	strings
+	v.ast
+)
+
+struct JsDoc {
+	gen &JsGen
+	mut:
+	out strings.Builder
+	empty_line bool
+}
+
+fn new_jsdoc(gen &JsGen) &JsDoc {
+	return &JsDoc {
+		out: strings.new_builder(20)
+		gen: gen
+	}
+}
+
+fn (d mut JsDoc) gen_indent() {
+	if d.gen.indents[d.gen.namespace] > 0 && d.empty_line {
+		d.out.write(tabs[d.gen.indents[d.gen.namespace]])
+	}
+	d.empty_line = false
+}
+
+fn (d mut JsDoc) write(s string) {
+	d.gen_indent()
+	d.out.write(s)
+}
+
+fn (d mut JsDoc) writeln(s string) {
+	d.gen_indent()
+	d.out.writeln(s)
+	d.empty_line = true
+}
+
+fn (d mut JsDoc) reset() {
+	d.out = strings.new_builder(20)
+	d.empty_line = false
+}
+
+fn (d mut JsDoc) gen_typ(typ string, name string) string {
+	d.reset()
+	d.write('/**')
+	d.write(' @type {$typ}')
+	if name.len > 0 {
+		d.write(' - $name')
+	}
+	d.write(' */')
+	return d.out.str()
+}
+
+fn (d mut JsDoc) gen_ctor(fields []ast.StructField) string {
+	d.reset()
+	d.writeln('/**')
+	d.write('* @param {{')
+	for i, field in fields {
+		d.write('$field.name: ${d.gen.typ(field.typ)}')
+		if i < fields.len-1 { d.write(', ') }
+	}
+	d.writeln('}} values - values for this class fields')
+	d.writeln('* @constructor')
+	d.write('*/')
+	return d.out.str()
+}
+
+fn (d mut JsDoc) gen_fn(it ast.FnDecl) string {
+	d.reset()
+	type_name := d.gen.typ(it.return_type)
+	d.writeln('/**')
+	for i, arg in it.args {
+		if it.is_method && i == 0 { continue }
+		arg_type_name := d.gen.typ(arg.typ)
+		is_varg := i == it.args.len - 1 && it.is_variadic
+		if is_varg {
+			d.writeln('* @param {...$arg_type_name} $arg.name')
+		} else {
+			d.writeln('* @param {$arg_type_name} $arg.name')
+		}
+	}
+	d.writeln('* @return {$type_name}')
+	d.write('*/')
+	return d.out.str()
+}
\ No newline at end of file
diff --git a/vlib/v/gen/js/tests/js.js b/vlib/v/gen/js/tests/js.js
new file mode 100644
index 0000000000..c065a50483
--- /dev/null
+++ b/vlib/v/gen/js/tests/js.js
@@ -0,0 +1,127 @@
+// V_COMMIT_HASH 83289d7
+// V_CURRENT_COMMIT_HASH fc7e64b
+
+// Generated by the V compiler
+"use strict";
+
+const CONSTANTS = Object.freeze({
+	/** @type {number} - i_am_a_const */
+	i_am_a_const: 21214
+});
+
+class Companies {
+	/**
+	* @param {{google: number, amazon: boolean, yahoo: string}} values - values for this class fields
+	* @constructor
+	*/
+	constructor(values) {
+		this.google = values.google
+		this.amazon = values.amazon
+		this.yahoo = values.yahoo
+	}
+	
+	/**
+	* @return {number}
+	*/
+	method() {
+		const it = this;
+		const ss = new Companies({
+			google: 2, 
+			amazon: true, 
+			yahoo: "hello"
+		});
+		/** @type {[number, number]} */
+		const [a, b] = hello(2, "google", "not google");
+		/** @type {string} - glue */
+		const glue = (a > 2 ? "more_glue" : a > 5 ? "more glueee" : "less glue");
+		if (a !== 2) {
+		}
+		
+		return 0;
+	}
+	
+}
+const POSITION = Object.freeze({
+	GO_BACK: 0,
+	DONT_GO_BACK: 1,
+});
+
+/* program entry point */
+(async function() {
+	/** @type {string} - v */
+	const v = "done";
+	{
+		/** @type {string} - _ */
+		const _ = "block";
+	}
+	
+	/** @type {number} - pos */
+	const pos = POSITION.GO_BACK;
+	/** @type {number} - dun */
+	const dun = CONSTANTS.i_am_a_const * 20;
+	for (let i = 0; i < 10; i++) {
+	}
+	
+	for (let i = 0; i < "hello".length; ++i) {
+		let x = "hello"[i];
+	}
+	
+	for (let x = 1; x < 10; ++x) {
+	}
+	
+	/** @type {number[]} - arr */
+	const arr = [1, 2, 3, 4, 5];
+	for (let tmp1 = 0; tmp1 < arr.length; ++tmp1) {
+		let a = arr[tmp1];
+	}
+	
+	/** @type {Map<string, string>} - ma */
+	const ma = new Map([
+		["str", "done"],
+		["ddo", "baba"]
+	]);
+	for (let [m, n] of ma) {
+		/** @type {string} - iss */
+		const iss = m;
+	}
+	
+	await new Promise(function(resolve){
+		async(0, "hello");
+		resolve();
+	});
+	
+})();
+
+
+/**
+* @param {number} num
+* @param {string} def
+* @return {void}
+*/
+function async(num, def) {
+}
+
+
+/* [inline] */
+/**
+* @param {number} game_on
+* @param {...string} dummy
+* @return {multi_return_int_int}
+*/
+function hello(game_on, ...dummy) {
+	for (let tmp2 = 0; tmp2 < dummy.length; ++tmp2) {
+		let dd = dummy[tmp2];
+		/** @type {string} - l */
+		const l = dd;
+	}
+	
+	(function defer() {
+		/** @type {string} - do */
+		const do = "not";
+	})();
+	return [game_on + 2, 221];
+}
+
+
+
+
diff --git a/vlib/v/gen/js/tests/js.v b/vlib/v/gen/js/tests/js.v
new file mode 100644
index 0000000000..c8f5d58a24
--- /dev/null
+++ b/vlib/v/gen/js/tests/js.v
@@ -0,0 +1,76 @@
+
+const (
+    i_am_a_const = 21214
+)
+
+struct Companies {
+	google int
+    amazon bool
+    yahoo string
+}
+
+enum POSITION {
+    GO_BACK,
+    DONT_GO_BACK
+}
+
+fn main() {
+    v := "done"
+    {
+        _ := "block"
+    }
+
+    pos := POSITION.GO_BACK
+
+    dun := i_am_a_const * 20
+
+    for i := 0; i < 10; i++ {}
+
+    for i, x in 'hello' {}
+
+    for x in 1..10 {}
+
+    arr := [1,2,3,4,5]
+    for a in arr {}
+
+    ma := {
+        'str':  "done"
+        'ddo': "baba"
+    }
+
+    for m, n in ma {
+        iss := m
+    }
+
+    go async(0, "hello")
+}
+
+fn async(num int, def string) {}
+
+[inline]
+fn hello(game_on int, dummy ...string) (int, int) {
+    defer {
+        do := "not"
+    }
+    for dd in dummy {
+        l := dd
+    }
+    return game_on + 2, 221
+}
+
+fn (it Companies) method() int {
+
+    ss := Companies {
+        google: 2
+        amazon: true
+        yahoo: "hello"
+	}
+
+   a, b := hello(2, 'google', 'not google')
+  
+   glue := if a > 2 { 'more_glue' } else if a > 5 {'more glueee'} else { 'less glue' } 
+
+    if a != 2 {}
+
+   return 0
+}
diff --git a/vlib/v/gen/jsgen.v b/vlib/v/gen/jsgen.v
deleted file mode 100644
index 67e2f32892..0000000000
--- a/vlib/v/gen/jsgen.v
+++ /dev/null
@@ -1,194 +0,0 @@
-module gen
-
-import (
-	strings
-	v.ast
-	v.table
-	term
-)
-
-struct JsGen {
-	out   strings.Builder
-	table &table.Table
-}
-
-pub fn jsgen(program ast.File, table &table.Table) string {
-	mut g := JsGen{
-		out: strings.new_builder(100)
-		table: table
-	}
-	for stmt in program.stmts {
-		g.stmt(stmt)
-		g.writeln('')
-	}
-	return (g.out.str())
-}
-
-pub fn (g &JsGen) save() {}
-
-pub fn (g mut JsGen) write(s string) {
-	g.out.write(s)
-}
-
-pub fn (g mut JsGen) writeln(s string) {
-	g.out.writeln(s)
-}
-
-fn (g mut JsGen) stmts(stmts []ast.Stmt) {
-	for stmt in stmts {
-		g.stmt(stmt)
-	}
-}
-
-fn (g mut JsGen) stmt(node ast.Stmt) {
-	match node {
-		ast.FnDecl {
-			type_sym := g.table.get_type_symbol(it.return_type)
-			g.write('/** @return { $type_sym.name } **/\nfunction ${it.name}(')
-			for arg in it.args {
-				arg_type_sym := g.table.get_type_symbol(arg.typ)
-				g.write(' /** @type { $arg_type_sym.name } **/ $arg.name')
-			}
-			g.writeln(') { ')
-			for stmt in it.stmts {
-				g.stmt(stmt)
-			}
-			g.writeln('}')
-		}
-		ast.Return {
-			g.write('return ')
-			if it.exprs.len > 0 {}
-			else {
-				g.expr(it.exprs[0])
-			}
-			g.writeln(';')
-		}
-		ast.AssignStmt {
-			if it.left.len > it.right.len {}
-			// TODO: multi return
-			else {
-				for i, ident in it.left {
-					var_info := ident.var_info()
-					var_type_sym := g.table.get_type_symbol(var_info.typ)
-					val := it.right[i]
-					g.write('var /* $var_type_sym.name */ $ident.name = ')
-					g.expr(val)
-					g.writeln(';')
-				}
-			}
-		}
-		ast.ForStmt {
-			g.write('while (')
-			g.expr(it.cond)
-			g.writeln(') {')
-			for stmt in it.stmts {
-				g.stmt(stmt)
-			}
-			g.writeln('}')
-		}
-		ast.StructDecl {
-			// g.writeln('typedef struct {')
-			// for field in it.fields {
-			// g.writeln('\t$field.ti.name $field.name;')
-			// }
-			g.writeln('var $it.name = function() {};')
-		}
-		ast.ExprStmt {
-			g.expr(it.expr)
-		}
-		/*
-			match it.expr {
-				// no ; after an if expression
-				ast.IfExpr {}
-				else {
-					g.writeln(';')
-				}
-	}
-	*/
-
-		else {
-			verror('jsgen.stmt(): bad node')
-		}
-	}
-}
-
-fn (g mut JsGen) expr(node ast.Expr) {
-	// println('cgen expr()')
-	match node {
-		ast.IntegerLiteral {
-			g.write(it.val)
-		}
-		ast.FloatLiteral {
-			g.write(it.val)
-		}
-		/*
-		ast.UnaryExpr {
-			g.expr(it.left)
-			g.write(' $it.op ')
-		}
-		*/
-
-		ast.StringLiteral {
-			g.write('tos3("$it.val")')
-		}
-		ast.InfixExpr {
-			g.expr(it.left)
-			g.write(' $it.op.str() ')
-			g.expr(it.right)
-		}
-		// `user := User{name: 'Bob'}`
-		ast.StructInit {
-			type_sym := g.table.get_type_symbol(it.typ)
-			g.writeln('/*$type_sym.name*/{')
-			for i, field in it.fields {
-				g.write('\t$field : ')
-				g.expr(it.exprs[i])
-				g.writeln(', ')
-			}
-			g.write('}')
-		}
-		ast.CallExpr {
-			g.write('${it.name}(')
-			for i, arg in it.args {
-				g.expr(arg.expr)
-				if i != it.args.len - 1 {
-					g.write(', ')
-				}
-			}
-			g.write(')')
-		}
-		ast.Ident {
-			g.write('$it.name')
-		}
-		ast.BoolLiteral {
-			if it.val == true {
-				g.write('true')
-			}
-			else {
-				g.write('false')
-			}
-		}
-		ast.IfExpr {
-			for i, branch in it.branches {
-				if i == 0 {
-					g.write('if (')
-					g.expr(branch.cond)
-					g.writeln(') {')
-				}
-				else if i < it.branches.len-1 || !it.has_else {
-					g.write('else if (')
-					g.expr(branch.cond)
-					g.writeln(') {')
-				}
-				else {
-					g.write('else {')
-				}
-				g.stmts(branch.stmts)
-				g.writeln('}')
-			}
-		}
-		else {
-			println(term.red('jsgen.expr(): bad node'))
-		}
-	}
-}
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
index a59627072e..60c6975530 100644
--- a/vlib/v/parser/fn.v
+++ b/vlib/v/parser/fn.v
@@ -8,12 +8,14 @@ import v.table
 import v.scanner
 import v.token
 
-pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
+pub fn (p mut Parser) call_expr(is_c bool, is_js bool, mod string) ast.CallExpr {
 	first_pos := p.tok.position()
 	tok := p.tok
 	name := p.check_name()
 	fn_name := if is_c {
 		'C.$name'
+	} else if is_js {
+		'JS.$name'
 	} else if mod.len > 0 {
 		'${mod}.$name'
 	} else {
@@ -51,6 +53,7 @@ pub fn (p mut Parser) call_expr(is_c bool, mod string) ast.CallExpr {
 		mod: p.mod
 		pos: pos
 		is_c: is_c
+		is_js: is_js
 		or_block: ast.OrExpr{
 			stmts: or_stmts
 			is_used: is_or_block_used
@@ -89,9 +92,10 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		p.next()
 	}
 	p.check(.key_fn)
-	// C.
+	// C. || JS.
 	is_c := p.tok.kind == .name && p.tok.lit == 'C'
-	if is_c {
+	is_js := p.tok.kind == .name && p.tok.lit == 'JS'
+	if is_c || is_js {
 		p.next()
 		p.check(.dot)
 	}
@@ -133,7 +137,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 	if p.tok.kind == .name {
 		// TODO high order fn
 		name = p.check_name()
-		if !is_c && !p.pref.translated && scanner.contains_capital(name) {
+		if !is_js && !is_c && !p.pref.translated && scanner.contains_capital(name) {
 			p.error('function names cannot contain uppercase letters, use snake_case instead')
 		}
 		if is_method && p.table.get_type_symbol(rec_type).has_method(name) {
@@ -179,6 +183,8 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 	} else {
 		if is_c {
 			name = 'C.$name'
+		} else if is_js {
+			name = 'JS.$name'
 		} else {
 			name = p.prepend_mod(name)
 		}
@@ -191,6 +197,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 			return_type: return_type
 			is_variadic: is_variadic
 			is_c: is_c
+			is_js: is_js
 			is_generic: is_generic
 		})
 	}
@@ -217,6 +224,7 @@ fn (p mut Parser) fn_decl() ast.FnDecl {
 		is_method: is_method
 		rec_mut: rec_mut
 		is_c: is_c
+		is_js: is_js
 		no_body: no_body
 		pos: pos
 		is_builtin: p.builtin_mod || p.mod in ['math', 'strconv', 'strconv.ftoa', 'hash.wyhash',
diff --git a/vlib/v/parser/parse_type.v b/vlib/v/parser/parse_type.v
index 346cde8891..dbd75d6994 100644
--- a/vlib/v/parser/parse_type.v
+++ b/vlib/v/parser/parse_type.v
@@ -109,11 +109,12 @@ pub fn (p mut Parser) parse_type() table.Type {
 		p.next()
 	}
 	is_c := p.tok.lit == 'C'
-	if is_c {
+	is_js := p.tok.lit == 'JS'
+	if is_c || is_js {
 		p.next()
 		p.check(.dot)
 	}
-	mut typ := p.parse_any_type(is_c, nr_muls > 0)
+	mut typ := p.parse_any_type(is_c, is_js, nr_muls > 0)
 	if is_optional {
 		typ = table.type_set(typ, .optional)
 	}
@@ -123,11 +124,14 @@ pub fn (p mut Parser) parse_type() table.Type {
 	return typ
 }
 
-pub fn (p mut Parser) parse_any_type(is_c, is_ptr bool) table.Type {
+pub fn (p mut Parser) parse_any_type(is_c bool, is_js bool, is_ptr bool) table.Type {
 	mut name := p.tok.lit
 	if is_c {
 		name = 'C.$name'
 	}
+	else if is_js {
+		name = 'JS.$name'
+	}
 	// `module.Type`
 	else if p.peek_tok.kind == .dot {
 		// /if !(p.tok.lit in p.table.imports) {
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index 6fea96cf43..6e0fdcd40c 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -21,6 +21,7 @@ mut:
 	peek_tok          token.Token
 	table             &table.Table
 	is_c              bool
+	is_js			  bool
 	inside_if         bool
 	inside_for        bool
 	inside_fn         bool
@@ -545,7 +546,7 @@ pub fn (p &Parser) warn_with_pos(s string, pos token.Position) {
 	eprintln(ferror)
 }
 
-pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
+pub fn (p mut Parser) parse_ident(is_c, is_js bool) ast.Ident {
 	// p.warn('name ')
 	pos := p.tok.position()
 	var name := p.check_name()
@@ -563,6 +564,7 @@ pub fn (p mut Parser) parse_ident(is_c bool) ast.Ident {
 		kind: .unresolved
 		name: name
 		is_c: is_c
+		is_js: is_js
 		mod: p.mod
 		pos: pos
 	}
@@ -618,6 +620,7 @@ fn (p mut Parser) struct_init(short_syntax bool) ast.StructInit {
 pub fn (p mut Parser) name_expr() ast.Expr {
 	var node := ast.Expr{}
 	is_c := p.tok.lit == 'C'
+	is_js := p.tok.lit == 'JS'
 	var mod := ''
 	// p.warn('resetting')
 	p.expr_mod = ''
@@ -629,16 +632,18 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		}
 	}
 	// Raw string (`s := r'hello \n ')
-	if p.tok.lit in ['r', 'c'] && p.peek_tok.kind == .string {
+	if p.tok.lit in ['r', 'c', 'js'] && p.peek_tok.kind == .string {
 		// QTODO
 		// && p.prev_tok.kind != .str_dollar {
 		return p.string_expr()
 	}
 	known_var := p.scope.known_var(p.tok.lit)
-	if p.peek_tok.kind == .dot && !known_var && (is_c || p.known_import(p.tok.lit) || p.mod.all_after('.') ==
+	if p.peek_tok.kind == .dot && !known_var && (is_c || is_js || p.known_import(p.tok.lit) || p.mod.all_after('.') ==
 		p.tok.lit) {
 		if is_c {
 			mod = 'C'
+		} else if is_js {
+			mod = 'JS'
 		} else {
 			// prepend the full import
 			mod = p.imports[p.tok.lit]
@@ -688,10 +693,10 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		} else {
 			// fn call
 			// println('calling $p.tok.lit')
-			x := p.call_expr(is_c, mod)			// TODO `node,typ :=` should work
+			x := p.call_expr(is_c, is_js, mod)			// TODO `node,typ :=` should work
 			node = x
 		}
-	} else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || (p.builtin_mod &&
+	} else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || is_c || is_js || (p.builtin_mod &&
 		p.tok.lit in table.builtin_type_names)) && !p.inside_match && !p.inside_match_case && !p.inside_if &&
 		!p.inside_for {
 		// (p.tok.lit.len in [1, 2] || !p.tok.lit[p.tok.lit.len - 1].is_capital()) &&
@@ -718,7 +723,7 @@ pub fn (p mut Parser) name_expr() ast.Expr {
 		}
 	} else {
 		var ident := ast.Ident{}
-		ident = p.parse_ident(is_c)
+		ident = p.parse_ident(is_c, is_js)
 		node = ident
 	}
 	p.expr_mod = ''
@@ -1549,13 +1554,14 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 		p.check(.key_union)
 	}
 	is_c := p.tok.lit == 'C' && p.peek_tok.kind == .dot
+	is_js := p.tok.lit == 'JS' && p.peek_tok.kind == .dot
 	if is_c {
-		p.next()		// C
+		p.next()		// C || JS
 		p.next()		// .
 	}
 	is_typedef := p.attr == 'typedef'
 	no_body := p.peek_tok.kind != .lcbr
-	if !is_c && no_body {
+	if !is_c && !is_js && no_body {
 		p.error('`$p.tok.lit` lacks body')
 	}
 	var name := p.check_name()
@@ -1644,6 +1650,8 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 	}
 	if is_c {
 		name = 'C.$name'
+	} else if is_js {
+		name = 'JS.$name'
 	} else {
 		name = p.prepend_mod(name)
 	}
@@ -1677,6 +1685,7 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 		pub_pos: pub_pos
 		pub_mut_pos: pub_mut_pos
 		is_c: is_c
+		is_js: is_js
 		is_union: is_union
 	}
 }
@@ -1743,7 +1752,7 @@ fn (p mut Parser) parse_assign_lhs() []ast.Ident {
 		if is_static {
 			p.check(.key_static)
 		}
-		var ident := p.parse_ident(false)
+		var ident := p.parse_ident(false, false)
 		ident.is_mut = is_mut
 		ident.info = ast.IdentVar{
 			is_mut: is_mut
diff --git a/vlib/v/table/table.v b/vlib/v/table/table.v
index 270a26f89a..3d3d69beca 100644
--- a/vlib/v/table/table.v
+++ b/vlib/v/table/table.v
@@ -25,6 +25,7 @@ pub:
 	return_type Type
 	is_variadic bool
 	is_c        bool
+	is_js		bool
 	is_generic  bool
 }
 
diff --git a/vlib/v/tests/in_expression_test.v b/vlib/v/tests/in_expression_test.v
index 3440b55d36..5c335ce6a6 100644
--- a/vlib/v/tests/in_expression_test.v
+++ b/vlib/v/tests/in_expression_test.v
@@ -17,12 +17,10 @@ fn test_in_expression() {
 	assert a == true
 	a = false && 0 in arr3
 	assert a == false
-
 	a = true && 0 in arr1
 	assert a == false
 	a = true && 3 in arr1
 	assert a == false
-
 	a = true && !(2 in arr2)
 	assert a == false
 	a = true && !(3 in arr2)
@@ -90,7 +88,6 @@ fn test_in_expression_with_string() {
 	assert a == false
 	a = true && 'abc' in arr1
 	assert a == false
-
 	a = true && !('bc' in arr2)
 	assert a == false
 	a = true && !('abc' in arr2)
@@ -118,12 +115,10 @@ fn test_optimized_in_expression() {
 	assert a == true
 	a = false && 0 in [1, 0]
 	assert a == false
-
 	a = true && 0 in [1, 2]
 	assert a == false
 	a = true && 3 in [1, 2]
 	assert a == false
-
 	a = true && !(2 in [0, 2])
 	assert a == false
 	a = true && !(3 in [0, 2])
@@ -151,12 +146,10 @@ fn test_optimized_in_expression_with_enum() {
 	assert a == true
 	a = false && Colors.red in [.green, .red]
 	assert a == false
-
 	a = true && Colors.red in [.green, .blue]
 	assert a == false
 	a = true && Colors.yellow in [.green, .blue]
 	assert a == false
-
 	a = true && !(Colors.blue in [.red, .blue])
 	assert a == false
 	a = true && !(Colors.yellow in [.red, .blue])
@@ -184,12 +177,10 @@ fn test_optimized_in_expression_with_string() {
 	assert a == true
 	a = false && '' in ['ab', '']
 	assert a == false
-
 	a = true && '' in ['ab', 'bc']
 	assert a == false
 	a = true && 'abc' in ['ab', 'bc']
 	assert a == false
-
 	a = true && !('bc' in ['', 'bc'])
 	assert a == false
 	a = true && !('abc' in ['', 'bc'])