{"canonical_url":"https://engineer.company/es/glossary/webassembly/","content_markdown":"# WebAssembly\n\n## Qué es\n\nWebAssembly, que suele abreviarse como Wasm, es un formato binario para código\nejecutable. Su especificación principal lo llama «un formato de código seguro, portable y de bajo nivel, diseñado para\nuna ejecución eficiente y una representación compacta» y lo\ndescribe como un conjunto de instrucciones virtual: las instrucciones de un\nprocesador imaginario, que un navegador u otro entorno anfitrión primero\ncomprueba y después traduce a código máquina para el procesador real. La forma\ncorta es una contracción, no una sigla; por eso la especificación escribe Wasm\ny no WASM.\n\nUn archivo `.wasm` suele ser el resultado de un compilador para otro lenguaje.\nEl objetivo principal, según la propia especificación, es que las aplicaciones\nweb sean rápidas, pero el formato no presupone la web: también puede ejecutarse\ncomo una máquina virtual independiente o dentro de otros programas. El estándar\nse divide en capas para reflejarlo: la especificación principal define las\ninstrucciones, los formatos, la validación y la ejecución, sin un entorno\nconcreto. Otros documentos definen la API de JavaScript que compila, enlaza e\ninvoca los módulos, y la API web que los carga por la red.\n\nLa primera versión se convirtió en Recomendación del W3C el 5 de diciembre de\n2019. La versión 2.0, prácticamente terminada tres años antes de su sucesora,\nañadió instrucciones vectoriales, operaciones masivas sobre la memoria,\nfunciones con más de un valor de retorno y una primera forma sencilla de tipos\nde referencia. El 17 de septiembre de 2025, el proyecto anunció la versión 3.0\ncomo estándar vigente e indicó que ya se distribuía en la mayoría de los\nprincipales navegadores. El mismo anuncio cita Java, OCaml, Scala, Kotlin,\nScheme y Dart entre los lenguajes que ya generan Wasm mediante su recolector\nde basura.\n\nEl vocabulario es reducido. La unidad de código es un módulo: contiene\nfunciones, tablas, memorias y variables globales; importa lo que necesita, con\nun nombre de módulo y otro de elemento para cada importación, y exporta lo que\nofrece bajo sus propios nombres. Hay cuatro tipos numéricos, enteros y números\nen coma flotante de 32 y 64 bits, escritos `i32`, `i64`, `f32` y `f64`, además\nde un único tipo vectorial de 128 bits y referencias opacas. Los enteros no\ntienen signo por sí mismos: cada operación los interpreta con o sin signo, y\nun entero de 32 bits también sirve como booleano. Las direcciones de memoria\nusan `i32` o, para una memoria de 64 bits, `i64`. Las instrucciones toman sus\noperandos de una pila implícita y dejan en ella los resultados. El flujo de\ncontrol es estructurado: bloques, bucles y condicionales se anidan, y un salto\nsolo puede dirigirse a uno de ellos.\n\nLos datos direccionados por bytes residen en una memoria lineal, una matriz\ncontinua de bytes que admite escritura, parte de un tamaño declarado y puede\ncrecer durante la ejecución. Una lectura o escritura fuera de su tamaño actual\nno alcanza nada más: provoca una trampa que detiene inmediatamente la ejecución.\nUna trampa no puede manejarse dentro de Wasm, solo notificarse al entorno\nanfitrión. El ejemplo siguiente usa el formato textual que la especificación\ndefine para que lo lean personas.\n\n## Por qué importa\n\nLa primera razón es la velocidad. Los objetivos de diseño piden un rendimiento\ncercano al código nativo y un formato que una sola pasada rápida pueda\ndecodificar, validar y compilar, tanto si el compilador trabaja durante la\nejecución como si lo hace de antemano. El binario pretende ser más compacto que\nel texto y que el código máquina nativo, y admite procesamiento en flujo: el\ntrabajo puede empezar antes de que llegue el último byte. Incluso mantiene la\ndeclaración de tipo de cada función en una sección distinta de su cuerpo para\nque los cuerpos puedan compilarse en paralelo y mientras llegan. Un equipo que\nya cuenta con una biblioteca bien probada en otro lenguaje puede compilarla\npara el navegador en lugar de reescribirla en JavaScript.\n\nLa segunda es la portabilidad. El mismo módulo se ejecuta en cualquier\nprocesador moderno, de escritorio o móvil, y en cualquier anfitrión que\nincorpore un motor: un navegador, un entorno de ejecución independiente u otro\nprograma. La especificación no favorece ningún lenguaje, modelo de programación\nni modelo de objetos concreto. El formato es, por tanto, un destino común de\ncompilación y no el entorno de ejecución privado de un lenguaje.\n\nLa tercera es el aislamiento. Un módulo no dispone de acceso implícito al\nequipo donde se ejecuta. Los archivos, la red, la página y el reloj quedan\nfuera de su alcance salvo que el anfitrión le entregue una función para ellos\ncomo importación; el anfitrión decide exactamente qué puede tocar el código.\nEn la web, la API web señala que Wasm puede ejecutarse donde se ejecute\nJavaScript, tiene esencialmente el mismo modelo de amenazas y no puede exponer\nmás de lo que JavaScript ya podría. La versión 3.0 amplió lo que cabe dentro\nde ese límite: memorias direccionables con 64 bits, limitadas en la web a 16\ngigabytes; varias memorias en un módulo; un recolector de basura para lenguajes\nque cuentan con él; y excepciones que ya no tienen que salir al anfitrión. El anuncio califica\nesa salida al anfitrión de no portátil e ineficiente.\n\n## Cómo se aplica en la práctica\n\nEste módulo en formato textual exporta una sola función que suma dos enteros\nde 32 bits:\n\n```wat\n(module\n  (func (export \"add\") (param i32 i32) (result i32)\n    local.get 0\n    local.get 1\n    i32.add))\n```\n\nEl tipo de la función indica que recibe dos valores `i32` y devuelve uno.\nEl cuerpo son tres instrucciones sobre la pila: `local.get 0` apila el primer\nparámetro, `local.get 1` el segundo, e `i32.add` retira ambos y apila su suma,\nque queda como resultado. `(export \"add\")` da a la función el nombre que ve\nel exterior. Convertido al formato binario, el archivo empieza por los cuatro\nbytes `0x00 0x61 0x73 0x6D`, un cero seguido de las letras asm, y después por\nla versión del formato binario, que sigue siendo 1.\n\nEn un navegador, la API de JavaScript lo carga así:\n\n```js\nconst url = \"/add.wasm\";\nconst { instance } = await WebAssembly.instantiateStreaming(fetch(url));\ninstance.exports.add(2, 3); // 5\ninstance.exports.add(2147483647, 1); // -2147483648\n```\n\n`instantiateStreaming` compila el módulo mientras todavía llega la respuesta\ny resuelve la promesa con el módulo compilado y una instancia. Las exportaciones\nde la instancia son funciones ordinarias de JavaScript. La segunda llamada\nmuestra qué significan los tipos: la suma de enteros en Wasm se calcula módulo\n2 elevado a 32, y la API de JavaScript interpreta un resultado `i32` con signo.\nPor eso, una unidad más que el mayor valor positivo vuelve como el valor más\nnegativo. No se lanza ninguna excepción. Una trampa sí la provocaría: si una\nfunción lee fuera de su memoria, la llamada termina con un\n`WebAssembly.RuntimeError`.\n\nUn módulo declara lo que necesita de su anfitrión. Si contiene\n`(import \"env\" \"log\" (func (param i32)))`, la instanciación necesita un segundo\nargumento, `{ env: { log: console.log } }`, y el módulo puede llamar a `log`\ncomo a cualquiera de sus propias funciones. Si se omite el segundo argumento,\nla instanciación falla con un `TypeError`; si se pasa un objeto `env` sin una\n`log` invocable, falla con un `WebAssembly.LinkError`. En ambos casos ocurre\nantes de que se ejecute código del módulo. Las importaciones y exportaciones\nconstituyen toda la frontera, con tipos declarados que incluyen números y\nreferencias; una dirección en la memoria del módulo es un `i32`, o un `i64`\npara una memoria de 64 bits.\n\n[Una entrada del portafolio sobre un cliente nativo de macOS en Swift 6](/es/portfolio/built-a-native-macos-client-in-swift-6/)\ndescribe la otra forma de reutilizar código de otro lenguaje. En ese trabajo,\nrealizado en agosto de 2026, un núcleo de Rust se enlazó a una aplicación Swift\ncomo archivo estático y se utilizó a través de su interfaz C, que la entrada\ntrata como el contrato. Una envoltura fina posee cada puntero y cada cadena que\ncruza la frontera; todo lo que devuelve la interfaz tiene una regla de propiedad.\nEquivocarse causa una fuga o un cierre inesperado sin aviso del compilador.\nAhí no interviene Wasm, y eso hace útil la comparación: el mismo problema de\nuna frontera estrecha entre dos lenguajes, resuelto mediante enlace nativo en\nlugar de una lista de importaciones y una memoria aislada.\n\n## Dónde surgen los problemas\n\n**La promesa se rechaza antes de compilar nada.** Si falta `Content-Type`, o\nsu valor es distinto de `application/wasm` sin distinguir mayúsculas, se\nproduce un `TypeError`. La especificación señala que no se admiten parámetros\nadicionales, ni siquiera un parámetro vacío como en `application/wasm;`. Un estado no satisfactorio\nfalla igual, y también una respuesta de otro origen cuyo acceso no esté autorizado\npor CORS. Corrija el tipo de medio y las cabeceras del servidor.\n`WebAssembly.instantiate` sobre bytes obtenidos por su cuenta evita la\ncomprobación del tipo de medio, pero pierde la compilación en flujo.\n\n**Una vista de memoria deja de funcionar.** JavaScript ve la memoria de un\nmódulo mediante `memory.buffer` y las matrices construidas sobre él. Para\nmemoria no compartida, ese búfer tiene longitud fija de forma predeterminada.\nCuando la memoria crece, la API de JavaScript desconecta ese búfer de longitud\nfija y lo sustituye por otro; las matrices construidas sobre el antiguo quedan\ndesconectadas de la memoria. Ocurre tras `memory.grow()` desde JavaScript y\ntambién tras una instrucción `memory.grow` dentro del módulo, durante una\nllamada que parece inocua desde fuera. Vuelva a crear las vistas desde\n`memory.buffer` después de cualquier llamada que pueda ampliar la memoria,\nen lugar de conservar una durante toda la vida de la página.\n\n**Esperar que Wasm acceda por sí solo a la página.** Un módulo no tiene\nacceso implícito a nada: cada efecto sobre la página, la red o el almacenamiento\npasa por una función que JavaScript le entrega como importación. Los tipos\ntambién importan en esa frontera: un `i64` cruza como `BigInt`, no como un valor de tipo Number,\ny una función con un parámetro o resultado `v128` lanza un `TypeError` cada\nvez que JavaScript la llama. Diseñe la lista de importaciones y exportaciones\ncomo una interfaz con números sencillos y mantenga los vectores del lado de\nWasm.\n\n**Confundir un entorno aislado con un programa seguro.** El aislamiento\nprotege al anfitrión frente al módulo. No protege al módulo frente a sí mismo.\nLa especificación afirma que el aislamiento no puede impedir que un lenguaje inseguro\ncompilado a Wasm corrompa su propia distribución de memoria dentro de la memoria\nlineal: un desbordamiento de búfer en código compilado sobrescribe los datos\ndel módulo, y solo un acceso más allá del final de toda la memoria provoca una\ntrampa. Mantenga las comprobaciones y pruebas del lenguaje de origen y trate\ncomo no fiables los datos que el módulo recibe del exterior.\n\n**Distribuir el binario sin protegerlo.** El registro de `application/wasm`\nindica que el formato no incluye protección de integridad ni de privacidad;\ncuando se necesitan, deben venir de fuera, por ejemplo mediante HTTPS. Como\nocurre con JavaScript, algunas formas de cargarlo y ejecutarlo están limitadas\npor Content Security Policy o por la política del mismo origen. Y puesto que\nWasm se convierte en código máquina sobre hardware real, la especificación\nprincipal advierte de que puede ser vulnerable a ataques de canal lateral en\nel hardware. Sirva los módulos mediante HTTPS y controle quién puede cambiar\nun módulo con el mismo cuidado que quién puede cambiar un script.\n\n## Lecturas adicionales\n\n- [WebAssembly Specification](https://webassembly.github.io/spec/core/)\n  — especificación principal de la versión 3.0: estructura, validación,\n  ejecución y formatos binario y textual.\n- [Introduction](https://webassembly.github.io/spec/core/intro/introduction.html)\n  — definición, objetivos de diseño, alcance de cada documento y\n  consideraciones de seguridad.\n- [WebAssembly JavaScript Interface](https://webassembly.github.io/spec/js-api/)\n  — compilación e instanciación desde JavaScript, paso de valores,\n  `Memory.grow` y las tres clases de error.\n- [WebAssembly Web API](https://webassembly.github.io/spec/web-api/)\n  — `instantiateStreaming`, comprobaciones de la respuesta y registro de\n  `application/wasm`.\n- [Wasm 3.0 Completed](https://webassembly.org/news/2025-09-17-wasm-3.0/)\n  — anuncio del 17 de septiembre de 2025 y novedades de la versión 3.0.\n- [WebAssembly Core Specification 1.0](https://www.w3.org/TR/wasm-core-1/)\n  — Recomendación del W3C del 5 de diciembre de 2019.\n\n\u003chttps://engineer.company/es/glossary/webassembly/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Qué es Wasm y cómo funciona un módulo: pila, memoria lineal, importaciones y exportaciones, carga desde JavaScript y problemas habituales.","formats":{"gemtext":"https://engineer.company/es/glossary/webassembly/index.gmi","gopher":"https://engineer.company/es/glossary/webassembly/gophermap","html":"https://engineer.company/es/glossary/webassembly/","json":"https://engineer.company/es/glossary/webassembly/index.json","markdown":"https://engineer.company/es/glossary/webassembly/index.md","pdf":"https://engineer.company/es/glossary/webassembly/index.pdf"},"kind":"page","language":"es","title":"¿Qué es WebAssembly?","url":"https://engineer.company/es/glossary/webassembly/","version":1}