---
title: "Rodando Go no Navegador com WebAssembly: Integração Real com JavaScript"
slug: javascript-wasm-go
date: 2025-09-22
category: "Arquitetura"
tags: ["golang", "webassembly", "wasm", "javascript", "react", "performance", "browsers"]
readTime: "3 min"
excerpt: "Como compilar código Go para WebAssembly e utilizá-lo lado a lado com JavaScript em uma aplicação React, explorando as possibilidades de performance, portabilidade e integração multi-linguagem."
url: https://eliseu.dev/blog/javascript-wasm-go
---

Já pensou em rodar **Go dentro do navegador** como se fosse apenas mais uma função JavaScript?  
Isso é possível graças ao **[WebAssembly (Wasm)](https://developer.mozilla.org/en-US/docs/WebAssembly)**.  

Veja um exemplo prático de como compilar um programa simples em Go, expor funções para o JavaScript e utilizá-las diretamente em qualquer aplicação web moderna.

## Por que usar Go + Wasm?

- 🚀 **Performance** próxima ao nativo no browser.  
- 🔒 **Privacidade**: processamento direto no cliente, sem enviar dados ao servidor.  
- 🌍 **Portabilidade**: o mesmo módulo `.wasm` roda no navegador, em ambientes serverless ou no backend.  
- 🐹 **Go** traz vantagens em concorrência (goroutines) e bibliotecas maduras, sem reescrever lógica em JS.  

E o melhor: você pode fazer o mesmo com **Rust, C/C++, C#, Python (Pyodide)** ou até **AssemblyScript** — escolhendo a linguagem mais adequada para cada cenário.

## Passo a passo: Hello World em Go + Wasm

1. **Crie o arquivo `main.go`:**

```go
package main

import "syscall/js"

func hello(this js.Value, args []js.Value) interface{} {
    return js.ValueOf("Hello from Go in WebAssembly!")
}

func main() {
    c := make(chan struct{}, 0)
    js.Global().Set("hello", js.FuncOf(hello))
    <-c
}
```

2. **Inicialize um módulo Go (necessário para compilar com Go Modules):**

```bash
go mod init example.com/wasm-demo
go mod tidy
```

3. **Compile para WebAssembly:**

```bash
GOOS=js GOARCH=wasm go build -o main.wasm
```

4. **Baixe ou copie o runtime JavaScript (`wasm_exec.js`):**

Se o Go foi instalado com Homebrew, normalmente o caminho é:

```bash
cp "$(go env GOROOT)/lib/wasm/wasm_exec.js" .
```

Se o arquivo não existir, baixe direto do repositório oficial, ajustando para sua versão (`go version`):

```bash
curl -o wasm_exec.js https://raw.githubusercontent.com/golang/go/go1.25.1/misc/wasm/wasm_exec.js
```

5. **Crie o `index.html` mínimo:**

```html
<script src="wasm_exec.js"></script>
<script>
  const go = new Go();
  WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject)
    .then((result) => {
      go.run(result.instance);
      alert(hello()); // chama a função Go exposta
    });
</script>
```

6. **Sirva os arquivos com `npx serve`:**

```bash
npx serve .
```

Depois abra `http://localhost:3000` no navegador e veja o Go rodando dentro do JavaScript 🎉.

## E agora?

Esse é só o “Hello World”.  
Mas o mesmo padrão pode ser usado para:  

- Processar **dados financeiros** (ex: CNAB, boletos, cálculos de risco).  
- Executar **cálculos matemáticos ou criptográficos** direto no browser.  
- Reaproveitar bibliotecas Go existentes em aplicações web modernas.  
- Rodar **simuladores ou regras de negócio** no cliente sem expor lógica sensível em JS.  

## Conclusão

O **WebAssembly** está se consolidando como uma ponte real entre linguagens e o ecossistema JavaScript.  
Você não precisa mais ficar limitado ao JS: pode escrever em **Go, Rust, C++ ou Python**, compilar para Wasm e rodar em qualquer lugar que suporte navegador ou Node.js.  

💬 Já experimentou rodar outra linguagem dentro do navegador usando WebAssembly?