# TypeScript-Go Dependencies: A Complete Breakdown of the Go Module Stack

> Examine the Go module stack for typescript-go. Discover its core runtime libraries, utility packages, and testing tools, all detailed in go.mod with no external native libraries.

- Repository: [Microsoft/typescript-go](https://github.com/microsoft/typescript-go)
- Tags: deep-dive
- Published: 2026-04-25

---

**TypeScript-Go relies on approximately fourteen Go modules spanning core runtime libraries (file system, JSON, concurrency), utility packages for hashing and metrics, and testing tools, all declared in `go.mod` and requiring no external native libraries.**

The `microsoft/typescript-go` repository represents a ground-up rewrite of the TypeScript compiler in Go. Understanding its **typescript-go dependencies** reveals how the project handles cross-platform I/O, high-performance AST serialization, and concurrent compilation without CGO requirements.

## Core Runtime Dependencies

The compiler’s foundation rests on eight direct dependencies declared in `go.mod` lines 5–18. These handle platform-specific I/O, JSON processing, and system-level operations.

- **Windows I/O Transport**: `github.com/Microsoft/go-winio v0.6.2` enables named-pipe communication in [`cmd/tsgo/lsp.go`](https://github.com/microsoft/typescript-go/blob/main/cmd/tsgo/lsp.go), supporting the Language Server Protocol on Windows.
- **Experimental JSON**: `github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433` powers AST serialization for the native-preview package that emits TypeScript ASTs to VS Code.
- **Concurrency Primitives**: `golang.org/x/sync v0.20.0` provides synchronization primitives for parallel parsing of large codebases.
- **System Integration**: `golang.org/x/sys v0.43.0`, `golang.org/x/term v0.42.0`, and `golang.org/x/text v0.36.0` handle low-level OS interaction, terminal control, and text processing across platforms.

## Utility and Performance Libraries

Four specialized packages optimize hashing, comparison, and resource monitoring.

- **Fast Hashing**: `github.com/zeebo/xxh3 v1.1.0` supplies non-cryptographic hashing for incremental compilation caches.
- **OS Metrics**: `github.com/mackerelio/go-osstat v0.2.7` captures memory and CPU statistics, used in [`internal/vfs/vfstest/vfstest_test.go`](https://github.com/microsoft/typescript-go/blob/main/internal/vfs/vfstest/vfstest_test.go) to verify virtual file system performance.
- **Deep Comparison**: `github.com/google/go-cmp v0.7.0` enables structural equality checks in the test harness.
- **Patience Diffing**: `github.com/peter-evans/patience v0.3.0` supports text diffing operations.

## Testing and Development Dependencies

The test suite relies on three additional modules, including indirect dependencies declared in `go.mod` lines 20–24.

- **Testing Framework**: `gotest.tools/v3 v3.5.2` provides assertions and test utilities.
- **Code Generation**: `github.com/matryer/moq v0.7.1` (indirect) auto-generates mock implementations of internal interfaces like those in `internal/vfs`.
- **CPU Detection**: `github.com/klauspost/cpuid/v2 v2.2.10` (indirect) enables hardware feature detection.

## How Dependencies Power the Architecture

These libraries integrate into specific compiler subsystems according to the source code analysis.

**LSP and Windows Integration**

The `go-winio` package facilitates native named-pipe transports in [`cmd/tsgo/lsp.go`](https://github.com/microsoft/typescript-go/blob/main/cmd/tsgo/lsp.go), allowing the `tsgo` binary to communicate with VS Code without TCP overhead on Windows.

**JSON AST Encoding**

In [`internal/parser/types.go`](https://github.com/microsoft/typescript-go/blob/main/internal/parser/types.go), AST node structures serialize through `github.com/go-json-experiment/json` for consumption by the native-preview package ([`_packages/native-preview/README.md`](https://github.com/microsoft/typescript-go/blob/main/_packages/native-preview/README.md)), bridging the Go compiler with TypeScript tooling.

**Virtual File System Testing**

The `vfstest` package ([`internal/vfs/vfstest/vfstest.go`](https://github.com/microsoft/typescript-go/blob/main/internal/vfs/vfstest/vfstest.go)) combines `go-osstat` for resource monitoring and `go-cmp` for structural validation, ensuring the virtual file system remains lightweight during heavy I/O operations.

## Working with TypeScript-Go Dependencies

### Serializing AST Nodes with the JSON Library

```go
package main

import (
    "fmt"
    "github.com/go-json-experiment/json"
)

func main() {
    // Encode a struct matching TypeScript AST node shape
    data, err := json.Marshal(struct {
        Kind string `json:"kind"`
        Name string `json:"name"`
    }{"Identifier", "myVar"})
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))
}

```

This pattern appears in the native-preview code path referenced in [`_packages/native-preview/lib/getExePath.js`](https://github.com/microsoft/typescript-go/blob/main/_packages/native-preview/lib/getExePath.js).

### Monitoring Memory in Tests

```go
package vfstest

import (
    "testing"
    "github.com/mackerelio/go-osstat/memory"
)

func TestMemoryFootprint(t *testing.T) {
    mem, err := memory.Get()
    if err != nil {
        t.Fatalf("cannot read memory stats: %v", err)
    }
    t.Logf("Total RAM: %d MB", mem.Total/1024/1024)
}

```

The test suite uses this approach in [`internal/vfs/vfstest/vfstest_test.go`](https://github.com/microsoft/typescript-go/blob/main/internal/vfs/vfstest/vfstest_test.go) to validate resource usage.

### Generating Mocks with Moq

```bash

# From the repository root:

go run github.com/matryer/moq -out mock_vfs.go -pkg vfs github.com/microsoft/typescript-go/internal/vfs InterfaceName

```

The `tool` stanza in `go.mod` declares `moq` for this exact workflow, creating deterministic mocks for unit tests.

## Summary

- **TypeScript-Go dependencies** are declared entirely in `go.mod` and consist of pure Go modules requiring no CGO or external native libraries.
- Core runtime libraries include `go-winio` for Windows IPC, `go-json-experiment/json` for AST serialization, and `golang.org/x/sync` for concurrency.
- Performance-critical operations rely on `xxh3` for hashing and `go-osstat` for system metrics.
- The `moq` tool and `gotest.tools` framework support the comprehensive test suite, including mock generation for interfaces in `internal/vfs`.

## Frequently Asked Questions

### Does TypeScript-Go depend on the original TypeScript compiler?

No. While `typescript-go` implements the TypeScript language specification, it is a ground-up rewrite in Go. It does not import or link against the original TypeScript codebase; instead, it uses Go-native dependencies like `go-json-experiment/json` for AST serialization and `go-winio` for system integration.

### Why does TypeScript-Go use an experimental JSON library?

The `github.com/go-json-experiment/json` module provides high-performance encoding capabilities required for the **native-preview** package. This experimental library supports the specific JSON AST format consumed by VS Code integration, as documented in [`_packages/native-preview/README.md`](https://github.com/microsoft/typescript-go/blob/main/_packages/native-preview/README.md).

### Are all TypeScript-Go dependencies pure Go modules?

Yes. Every dependency listed in `go.mod`—including `github.com/Microsoft/go-winio` and the `golang.org/x/*` extensions—is implemented in pure Go. This design ensures the compiler builds and runs on any platform supported by the Go toolchain without requiring external native libraries or CGO.

### How are mocks generated in the TypeScript-Go test suite?

The project uses `github.com/matryer/moq`, declared as a tool dependency in `go.mod`, to auto-generate mock implementations of interfaces. Developers run `go run github.com/matryer/moq` to create type-safe mocks for packages like `internal/vfs`, enabling deterministic unit testing without filesystem side effects.