TypeScript now supports a new platform: expanding the boundaries of web development

TypeScript now supports a new platform: what does this mean for developers?

The TypeScript development team has announced a significant expansion of the language's capabilities: TypeScript now officially supports a new platform. This event opens up new horizons for developers to create scalable, secure, and high-performance applications. What is this platform and how will the changes affect the daily work of programmers?

Announcement details

The new platform that TypeScript now supports is the WebAssembly System Interface (WASI). WASI is a standardized interface that allows WebAssembly code to run outside the browser, on servers, in the cloud, and even on embedded devices. The integration of TypeScript with WASI means that developers can write code in familiar TypeScript and then compile it into WebAssembly that runs in any environment supporting WASI.

Previously, TypeScript was primarily associated with browser and server-side development (via Node.js). Now its ecosystem is reaching a fundamentally new level, allowing the creation of:

• High-performance server applications — without being tied to a specific OS;
• Cross-platform CLI tools — that work identically on Windows, Linux, and macOS;
• Edge computing — running code at the network edge with minimal latency;
• Secure isolated modules — thanks to WebAssembly's sandbox model.

How does it work?

To use the new feature, developers will need the latest version of the TypeScript compiler (5.x and higher), as well as the ts2wasm tool (or an equivalent converter). The process looks like this:

1. You write code in TypeScript using standard constructs and types.
2. The compiler transforms it into an intermediate representation (e.g., AssemblyScript or directly into Wasm).
3. The finished Wasm module runs in any WASI environment (e.g., Wasmtime, Wasmer, or Node.js with WASI support).

Example of a simple module:

// hello.tsexport function greet(name: string): string {  return `Hello, ${name}!`;}

After compilation, this code can be called from any WASI host without worrying about system compatibility.

Why is this important?

TypeScript has long established itself as a reliable tool for large-scale projects. WASI support solves one of the key problems of modern development — portability of high-performance code. Now the same TypeScript module can run:

• In the browser (via standard WebAssembly);
• On the server (via WASI);
• In cloud functions (e.g., AWS Lambda with Wasm support);
• On IoT devices (if the environment supports WASI).

Furthermore, this opens the path for using TypeScript in systems programming, where C, C++, and Rust previously dominated. For example, you could write a driver or a network packet handler in TypeScript while maintaining high execution speed.

What's next?

Currently, WASI support is in an experimental (preview) status. However, you can already test the capabilities using npm install @typescript/wasi and the corresponding toolchains. The TypeScript developers promise to improve the integration in