TypeNative

Build native applications using Typescript.

PreRequisites

• Nodejs v24 or newer.
• Go 1.21 or newer.

Get Started

• Write a file test.ts with content console.log('Hello World!'); or any other message
• Run npx typenative --source test.ts --script

Typescript Syntax Support

TypeNative currently supports a focused subset of TypeScript syntax elements that are transpiled to Go code. The support is grouped by topic for easier scanning.

Basic Types

| Feature | Supported | Notes | | -------------- | :-------: | ------------------------------------------------------------- | | number | ✅ | Transpiled to float64 | | boolean | ✅ | Transpiled to bool | | string | ✅ | | | null | ✅ | | | any | ✅ | Used for type inference | | Nullable types | ✅ | T \| null / T \| undefined transpiled to Go pointer types |

Variables & Objects

| Feature | Supported | Notes | | ---------------------- | :-------: | ----------------------------------------------- | | Variable declarations | ✅ | let and const | | Object literals | ✅ | Transpiled to Go struct literals | | Object shorthand | ✅ | { name } → { name: name } | | Array destructuring | ✅ | const [a, b] = arr | | Object destructuring | ✅ | const { x, y } = obj |

Operators

| Feature | Supported | Notes | | ------------------------ | :-------: | ------------------------------ | | Arithmetic operators | ✅ | +, -, etc. | | Comparison operators | ✅ | ==, !=, ===, !==, etc. | | Logical operators | ✅ | &&, \|\| | | Increment/Decrement | ✅ | ++, -- | | Spread operator | ✅ | [...arr], fn(...args) | | Non-null assertion (!) | ✅ | Stripped during transpilation | | Ternary expressions | ✅ | condition ? a : b | | Nullish coalescing | ✅ | ?? operator | | Optional chaining | ✅ | obj?.prop, arr?.[i] |

Control Flow

| Feature | Supported | Notes | | ------------------ | :-------: | ------------------------------------------------------ | | If/Else statements | ✅ | Fully supported | | Switch statements | ✅ | Case and default statements | | For loops | ✅ | Standard for loops | | For...of loops | ✅ | Arrays, Maps, Sets; Object.entries() unwrapping | | For...in loops | ✅ | Iterates keys via Go range | | While loops | ✅ | Transpiled to Go's for loops | | Do...while loops | ✅ | Implemented with conditional break | | Try/Catch/Finally | ✅ | throw → panic; catch/finally via defer/recover |

Data Structures & Array Methods

| Feature | Supported | Notes | | -------------------------- | :-------: | --------------------------------------------------------------------------------------------- | | Arrays | ✅ | Basic array operations | | Array methods | ✅ | push, pop, shift, unshift, join, slice, concat, reverse, sort, flat, at | | Higher-order array methods | ✅ | .map(), .filter(), .some(), .find(), .findIndex(), .every(), .forEach(), .reduce() | | Method chaining | ✅ | e.g. .map(...).filter(...).join(...) | | Map | ✅ | Map<K, V> → Go map[K]V; .set(), .get(), .has(), .delete(), .clear(), .size | | Set | ✅ | Set<T> → Go map[T]struct{}; .add(), .has(), .delete(), .clear(), .size |

Functions

| Feature | Supported | Notes | | ---------------------------- | :-------: | ----------------------------------------------------------- | | Function declarations | ✅ | Transpiled to Go functions | | Arrow functions | ✅ | Transpiled to anonymous functions | | IIFEs | ✅ | (() => { ... })() and (function name() { ... })() | | Closures over mutable state | ✅ | Functions capturing and mutating outer variables | | Function types | ✅ | () => number, (x: number) => string as type annotations | | Generics (functions/classes) | ✅ | Type parameters via Go generics | | Default parameter values | ✅ | function(x = defaultValue) | | Rest parameters | ✅ | function(...args: T[]) → Go variadic |

Classes & Interfaces

| Feature | Supported | Notes | | ------------------- | :-------: | -------------------------------------------------------------- | | Classes | ✅ | Transpiled to Go structs with constructor and receiver methods | | Class inheritance | ✅ | extends via embedded structs, super() supported | | Static members | ✅ | static method() / static prop → package-level declarations | | Getters / Setters | ✅ | get prop() → Get_prop(), set prop(v) → Set_prop(v) | | Interfaces | ✅ | Transpiled to Go interfaces, supports extends | | Optional properties | ✅ | prop?: Type in interfaces/types | | Enums | ✅ | enum declarations and member access |

Async & Timing

| Feature | Supported | Notes | | ----------- | :-------: | ----------------------------------------------------------------- | | Async/Await | ✅ | async functions return Go channels, await reads from channels | | Promises | ✅ | new Promise transpiled to channel + goroutine pattern | | setTimeout | ✅ | Mapped to Go's time.AfterFunc |

Built-in Functions & Utilities

| Feature | Supported | Notes | | --------------------- | :-------: | ----------------------------------------------------- | | console.log | ✅ | Mapped to fmt.Println | | console.error | ✅ | Mapped to fmt.Fprintln(os.Stderr, ...) | | console.time/timeEnd | ✅ | Performance measurement via time.Now / time.Since | | assert | ✅ | Transpiled to panic on failure | | parseInt / parseFloat | ✅ | Mapped to Go's strconv package | | JSON.stringify | ✅ | Mapped to encoding/json Marshal / MarshalIndent | | JSON.parse | ✅ | Mapped to encoding/json Unmarshal | | Object.keys/values | ✅ | Map key/value iteration helpers | | process.argv | ✅ | Mapped to os.Args | | process.platform | ✅ | Mapped to runtime.GOOS | | process.exit | ✅ | Mapped to os.Exit |

Math Methods

| Feature | Supported | Notes | | ------------------------- | :-------: | ------------------------------------------------- | | Math.random | ✅ | Mapped to rand.Float64() | | Math.floor / ceil / round | ✅ | Mapped to math.Floor, math.Ceil, math.Round | | Math.abs / sqrt / pow | ✅ | Mapped to corresponding math functions | | Math.min / max | ✅ | Mapped to math.Min, math.Max | | Math.log / log2 / log10 | ✅ | Mapped to math.Log, math.Log2, math.Log10 | | Math.sin / cos / tan | ✅ | Mapped to math.Sin, math.Cos, math.Tan | | Math.trunc / sign | ✅ | Mapped to math.Trunc and inline sign check |

String Methods

| Feature | Supported | Notes | | -------------------------- | :-------: | --------------------------------------------- | | Template literals | ✅ | Backtick strings with ${expr} interpolation | | toUpperCase / toLowerCase | ✅ | Via strings package | | trim / trimStart / trimEnd | ✅ | Via strings package | | split / includes / indexOf | ✅ | Via strings package | | startsWith / endsWith | ✅ | Via strings package | | replace / replaceAll | ✅ | Via strings package | | charAt / substring / slice | ✅ | Direct Go string indexing/slicing | | concat / repeat | ✅ | String concatenation and strings.Repeat | | padStart / padEnd | ✅ | Via strings.Repeat | | match / matchAll / search | ✅ | Via regexp package | | at | ✅ | Supports negative indices |

Number / Object Methods

| Feature | Supported | Notes | | -------- | :-------: | ----------------------------------------------------- | | toString | ✅ | Universal toString() via fmt.Sprintf for any type |

RegExp

| Feature | Supported | Notes | | -------------- | :-------: | --------------------------------------------------- | | Regex literals | ✅ | /pattern/flags transpiled to regexp.MustCompile | | new RegExp() | ✅ | Constructor with optional flags | | test() | ✅ | Mapped to regexp.MatchString | | exec() | ✅ | Mapped to regexp.FindStringSubmatch |

Modules & Imports

| Feature | Supported | Notes | | ------------------------ | :-------: | ------------------------------------------------------------------ | | Named imports | ✅ | import { x } from './file' | | Default imports | ✅ | import x from 'pkg' — namespace stripped in output | | Namespace imports | ✅ | import * as x from 'pkg' | | Local file imports | ✅ | Relative paths transpiled to a separate Go file | | Node.js built-in imports | ✅ | import { join } from 'node:path' mapped to Go stdlib | | Go package imports | ✅ | import { x } from 'go:pkg' | | npm package imports | ✅ | import { x } from 'pkg' mapped to Go module imports | | Named exports | ✅ | export function / export const declarations |

TypeNative is currently in early development and new features are being added regularly. The goal for 1.0 release is for TypeNative to transpile itself.