Hubbry Logo
EmscriptenEmscriptenMain
Open search
Emscripten
Community hub
Emscripten
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Emscripten
Emscripten
Emscripten
View on Wikipedia
from Wikipedia
Emscripten
Original authorAlon Zakai
Initial release22 October 2011 (2011-10-22)[1]
Stable release
4.0.19[2] Edit this on Wikidata / 4 November 2025; 1 day ago (4 November 2025)
Repository
Written inC, C++, JavaScript[3]
TypeCompiler
LicenseMIT License, University of Illinois/NCSA Open Source License
Websiteemscripten.org Edit this on Wikidata

Emscripten is an LLVM/Clang-based compiler that compiles C and C++ source code to WebAssembly,[4] primarily for execution in web browsers.

Emscripten allows applications and libraries written in C or C++ to be compiled ahead of time and run efficiently in web browsers, typically at speeds comparable to or faster than interpreted or dynamically compiled JavaScript. It even emulates an entire POSIX operating system, enabling programmers to use functions from the C standard library (libc).[5]

With the more recent development of the WebAssembly System Interface (WASI)[6] and WebAssembly runtimes such as Node.js, Wasmtime,[7] and Wasmer,[8] Emscripten can also be used to compile to WebAssembly for execution in non-Web embeddings as well.

Usage

[edit]

Emscripten has been used to port a number of C/C++ code bases to WebAssembly, including Unreal Engine 3, SQLite,[9] MeshLab,[10] Bullet physics,[11] AutoCAD,[12] and a subset of the Qt application framework.[13] Other examples of software ported to WebAssembly via Emscripten include the following:

Game engines

[edit]

The Unity, Defold, and Godot game engines provide an export option to HTML5, utilizing Emscripten.[14][15][16] Unreal Engine had this export option but it has been migrated out of the engine to a community member plug in.[17] The Source Engine, has a community developed port for Emscripten dubbed "HalfLife2JS".[18]

Frameworks & toolkits

[edit]

openFrameworks exports native C++ applications to HTML5 via Emscripten.[19] emscripten-qt permits compiling applications written using the Qt application framework to WebAssembly.[13]

Software archiving

[edit]

In December 2014, the Internet Archive launched a DOSBox emulator compiled in Emscripten to provide browser-based access to thousands of archived MS-DOS and PC programs.[20][21][22]

Creation

[edit]

Emscripten was created by Alon Zakai in 2010, motivated by his desire to port his fork of the open source first-person shooter game Sauerbraten, known as Syntensity,[23] to the web. Sauerbraten (also known as Cube 2) is an open source FPS game,[24] and Syntensity was Zakai's project that extended the Cube 2 Engine for greater flexibility. Observing the increasing shift of applications to web browsers, Zakai began developing Emscripten as an LLVM-to-JavaScript compiler, aiming to make it possible to run existing C and C++ code, such as game engines, directly in the browser. In early blog posts, Zakai explained that his long-term goal was "to run Syntensity, or a smaller version of it, on the web",[25] and Emscripten was released as open source shortly after its initial development, making it available for the broader community to experiment with and contribute to.[26][27]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Emscripten

View on Grokipedia
from Grokipedia
Emscripten is an open-source compiler toolchain that converts C, C++, and other LLVM-based languages into WebAssembly and JavaScript, enabling the execution of native code in web browsers, Node.js, and various WebAssembly runtimes with a focus on performance, size optimization, and web platform compatibility. Originally developed by Alon Zakai at Mozilla in 2011 as an LLVM-to-JavaScript compiler to port C/C++ applications to the web, Emscripten initially targeted JavaScript output but evolved to support asm.js in 2013 for faster execution and fully transitioned to WebAssembly as its primary output format following the standard's maturation around 2017. The toolchain leverages Clang (the C/C++ frontend of LLVM), the LLVM backend for intermediate representation, Binaryen for WebAssembly-specific optimizations, and tools like the Closure Compiler for JavaScript minification, with the Emscripten Compiler Frontend (emcc) serving as a drop-in replacement for gcc or clang. Emscripten has been instrumental in porting large-scale applications to the web, including game engines such as Unreal Engine 4—demonstrated in a 2014 and collaboration running complex 3D demos in —and Unity, which integrated WebAssembly support in 2018 to enable high-performance web-based games. It also supports libraries like SDL2 for graphics and input, OpenGL ES 2.0/ for rendering, and indirect compilation for languages such as Python, , and , making it a versatile tool for cross-platform development. Distributed via the Emscripten SDK, which includes all necessary dependencies like Python and , it runs on , Windows, and macOS, fostering a wide ecosystem of ports and demos available on its repository.

Overview

Purpose and Capabilities

Emscripten is an open-source compiler toolchain based on that translates , , and other LLVM-based languages, including , into and for execution in web browsers, , and other WebAssembly-supporting environments. Developed by Alon Zakai at , it was first introduced in 2011 to enable the porting of C++ applications to the web, demonstrating capabilities through early examples like running the classic game Doom in a browser. The toolchain's core capabilities center on facilitating high-performance execution of native-like code in web environments by compiling to , which serves as the primary output format and delivers execution speeds approaching those of native binaries. It maintains support for as a legacy JavaScript subset for compatibility with older browsers, while introducing experimental support starting in 2017 with version 1.37.0, which provided the binary instruction format; became the primary output format with further maturation in subsequent versions, such as 1.39.0 in 2019. Emscripten provides significant benefits, including cross-platform portability that allows a single codebase to run across diverse runtimes without modification, and direct access to web APIs from C and C++ via comprehensive bindings and a POSIX-like environment. Performance is further optimized through techniques such as dead code elimination to reduce binary size and support for SIMD instructions to accelerate vectorized computations, enabling applications to achieve near-native efficiency in resource-constrained web settings. Prior to WebAssembly's arrival, Emscripten addressed early web performance limitations by targeting asm.js, a structured subset of JavaScript designed for efficient just-in-time compilation.

Key Components

Emscripten serves as a complete compiler toolchain that enables the compilation of C and C++ code to WebAssembly and JavaScript, facilitating deployment on web platforms. Its key components include core tools for building and testing, supporting libraries for runtime compatibility, and management utilities for setup, all integrated to streamline the development process. The core tools form the primary interface for compiling and managing Emscripten projects. The emcc (Emscripten Compiler Frontend) acts as a command-line wrapper that serves as a drop-in replacement for standard compilers like gcc or clang, handling the invocation of the full compilation pipeline from source code to optimized WebAssembly modules. It processes C and C++ inputs, applies optimizations, and generates outputs suitable for the web. For projects using autotools-based build systems, emconfigure and emmake provide integration by setting environment variables to redirect the configure script and make invocations to use emcc instead of native compilers, ensuring compatibility with existing makefiles. Additionally, emrun functions as a utility to launch a local web server for running and debugging generated HTML files directly in a browser, simplifying testing without manual server setup. Supporting libraries underpin the runtime environment for compiled code. Emscripten's libc is a musl-based implementation of the , adapted to provide POSIX-like functionality within the constraints of the , including emulation and threading support. The libcxx (LLVM's libc++) delivers the , enabling features like STL containers and algorithms in environments. Binaryen, a toolkit, is integrated during the linking phase to optimize binary modules for size and performance, performing transformations such as and inlining. Emscripten's frontend relies on Clang/LLVM for parsing and intermediate representation, supporting C11, , and standards fully as of 2025, with flags like -std=c++20. This integration allows developers to leverage modern language features while targeting web runtimes. The emsdk (Emscripten SDK) manages installation and versioning, providing pre-built packages that include Clang, , and other dependencies for quick setup across platforms. Users can install specific releases, such as sdk-4.0.19-64bit, and switch versions via commands like emsdk activate, ensuring reproducible builds.

History and Development

Origins and Early Development

Emscripten was developed by Alon Zakai at , with initial work beginning in early 2011 to address the challenge of executing and code in web browsers at reasonable speeds. The primary motivation stemmed from the desire to port C++-based libraries and engines, such as the , directly to without significant performance loss. Zakai's approach leveraged the compiler infrastructure to translate low-level assembly into , exploiting features like typed arrays for efficient numeric computation. The project gained public attention through its presentation at the ACM conference in October 2011, marking the first formal release of Emscripten as an open-source tool under the . Early development emphasized generating code optimized for browser execution, with a focus on the emerging subset to achieve near-native performance by enabling optimizations in engines. This subset allowed Emscripten to produce typed, low-level code that browsers could validate and optimize efficiently, laying the groundwork for running computationally intensive applications on the web. A significant early milestone came in 2012 with the porting of the Cube 2: Sauerbraten engine to create BananaBread, a full that ran entirely in the browser using Emscripten-compiled C++ and for graphics. This demonstration highlighted Emscripten's potential for complex, interactive software, including 3D rendering and physics simulation, without requiring plugins. By 2013, the Emscripten SDK reached version 1.0, incorporating foundational support for through emulation via the API, which enabled portable graphics code across web environments. As Emscripten matured, it transitioned from a Mozilla-hosted initiative to a community-driven open-source project, maintaining permissive licensing to encourage widespread adoption and contributions.

Major Milestones and Updates

Emscripten began integrating more deeply in 2017 through the adoption of the upstream backend, which marked a significant shift from its earlier foundations by reducing reliance on glue code, thereby enhancing binary sizes and runtime performance. This integration laid the groundwork for more efficient compilation pipelines, allowing and code to target directly with improved speed and portability across browsers. Key releases further advanced these capabilities. In May 2018, Emscripten began defaulting to output. Emscripten 1.38.17, released in November 2018, provided full support, enabling stable production use of WASM outputs without fallback to . In 2020, introduced robust multi-threading support via SharedArrayBuffer, allowing parallel execution in web workers and addressing previous limitations in concurrent processing for complex applications. Version 3.1, launched in 2021, incorporated WebAssembly System Interface (WASI) support, facilitating system-level interfaces for file I/O and networking in non-browser environments. As of November 2025, Emscripten 4.0.19 includes optimizations for SIMD instructions and threading, enabling vectorized computations and finer-grained concurrency controls that outperform earlier implementations in compute-intensive tasks. These updates address gaps in pre- coverage by prioritizing modern WASM features for broader compatibility. Post-Mozilla, the transitioned to community-driven on under the emscripten-core organization around 2018, fostering contributions from the WebAssembly Working Group and external developers to sustain rapid iteration. Additionally, since 2019, Emscripten has supported compilation through integration with wasm-bindgen, allowing seamless binding of Rust modules to and Emscripten-generated WASM for hybrid language workflows.

Technical Architecture

Compilation Pipeline

The compilation pipeline in Emscripten orchestrates the transformation of C and C++ into browser-executable artifacts, primarily modules and supporting , through a multi-stage process driven by the emcc frontend. This pipeline leverages infrastructure to ensure compatibility with the web's constrained environment, where traditional native system interfaces are unavailable. The stages are designed to handle parsing, optimization, and code generation while emulating necessary runtime behaviors. In the frontend stage, —the C/C++ frontend of —parses the input source files and generates (IR) or object files (e.g., .o files). This step supports standard compilation flags, such as -c for producing intermediate objects without linking, and includes options for embedding debug information via -g to facilitate later . The IR serves as a portable, high-level representation that abstracts platform-specific details, allowing subsequent stages to focus on web-targeted transformations. The middle-end stage applies LLVM's optimization passes to the generated IR or bitcode, refining the code for performance and size. Optimizations are controlled by flags like -O2 for balanced speed improvements or -Oz for minimal code size, which are crucial in the web context to reduce download times and memory usage. This phase occurs during both compilation and linking, enabling link-time optimization (LTO) when specified, and prepares the IR for backend-specific generation without altering the core logic. The backend stage converts the optimized IR into final output formats, with Emscripten employing the upstream LLVM WebAssembly backend by default since version 1.39.0 in 2019. This backend generates binaries directly, followed by processing through Binaryen—a —for further optimizations like and inlining, which enhance execution speed and reduce module size. In contrast, the legacy fastcomp backend, used for generating , was deprecated in Emscripten 2.0.0 in August 2020 and is no longer supported in recent versions, as it relied on an older, custom fork that limited feature parity with modern developments. The shift to upstream integration has resulted in notable improvements, including an average code size reduction of 3.7% across benchmarks and up to 15% for larger applications like , due to better optimization passes and stricter feature linking. Emscripten addresses the web's lack of native operating system support by emulating APIs through bindings, intercepting system calls at runtime and mapping them to browser primitives. For instance, file operations are handled via virtual file systems like MEMFS (in-memory) or IDBFS (IndexedDB-backed), while networking APIs emulate sockets over WebSockets to enable TCP-like communication without direct server access. These bindings are integrated into the generated glue code, ensuring that standard C library functions (e.g., open, read, socket) execute correctly in the browser sandbox, often with minimal source modifications required. For error handling and , the pipeline incorporates source maps to bridge the compiled output back to original source code, enabled via the -gsource-map flag during linking. These maps, generated from debug information, allow browser developer tools (e.g., Chrome DevTools) to display C/C++ line numbers and stack traces during runtime errors or breakpoints, supporting production debugging even with optimizations applied. While source maps provide location accuracy across all major browsers, advanced features like variable inspection require retention and browser-specific extensions.

Output Generation and Optimization

Emscripten produces output in several formats to facilitate deployment in web environments. The primary artifact is a module in a binary .wasm file, which contains the compiled machine code from or sources. Accompanying this is glue code in a .js file, which handles bridging between the WebAssembly module and browser , such as DOM manipulation and event handling. For complete standalone applications, Emscripten can generate an HTML shell file that embeds the necessary JavaScript loader and canvas elements, allowing the application to run directly in a web browser without additional setup. To enhance the performance and reduce the size of the generated outputs, Emscripten supports various optimization flags during compilation. The -O3 flag enables aggressive optimizations, including function inlining, , and , which can significantly improve runtime speed at the cost of longer compilation times. Integration with the Closure Compiler is available via the --closure 1 option, which minifies the glue code by removing unnecessary whitespace, shortening variable names, and applying advanced removal, often reducing the .js file size by substantial margins. Multi-threading support is provided through , enabled by the -pthread flag, which allows parallel execution of C++ threads in the browser using Web Workers, though it requires careful management to avoid overhead from thread communication. A key optimization technique involves Binaryen passes, such as asyncify, which instrument synchronous C++ code to interact seamlessly with the asynchronous web environment. Asyncify transforms blocking operations into resumable states, enabling calls to asynchronous APIs like fetch() to appear synchronous from the C++ perspective, thus preserving the original program's flow without manual rewriting. This pass adds some runtime overhead and increases module size but is essential for legacy codebases relying on synchronous I/O. compression typically reduces the size of modules by 60-75% compared to their uncompressed sizes, contributing to faster loading times in production deployments. For performance tuning, Emscripten includes built-in profiling capabilities activated by the --profiling flag, which embeds to measure execution time and function calls within the compiled code. This generates detailed metrics accessible via the browser's developer tools, such as Chrome DevTools' Performance panel, where execution traces can be analyzed alongside . These tools help identify bottlenecks, such as frequent bridges or inefficient access, allowing developers to iterate on optimizations like adjusting allocation or reducing interactions.

Applications and Use Cases

Game Development

Emscripten facilitates game development by compiling C and C++-based game engines and codebases to , enabling high-performance execution in web browsers without plugins. This portability has allowed developers to target the web alongside native platforms, leveraging browser APIs like for 3D graphics and WebAudio for immersive soundscapes. By bridging traditional game development tools with web technologies, Emscripten has democratized access to browser-based gaming, supporting everything from indie titles to ports of legacy games. Major game engines have integrated Emscripten to export projects directly to the web. Unity uses Emscripten as the core compiler for builds, with the IL2CPP scripting backend—introduced for in Unity 2016—converting C# code to C++ intermediates before Emscripten generates optimized modules. Godot engine added full export support via Emscripten in version 3.2, released in January 2020, enabling seamless deployment of both 2D and 3D games with native-like performance in browsers. provided HTML5 targets through Emscripten integration from 4.3 in 2015 to 4.27 in 2020, with community-maintained plugins available for later versions including 5 as of 2025, allowing developers to package high-fidelity projects for web delivery while utilizing the engine's visual scripting and C++ codebase. Notable examples demonstrate Emscripten's practical impact on game ports. In 2011, Emscripten's creator Alon Zakai compiled the original to , marking an early milestone in web gaming; this port rendered the 1993 classic using for graphics acceleration and WebAudio for dynamic sound, running at interactive frame rates in contemporary browsers. Similarly, community-driven ports of have employed Emscripten to reimplement the title in , preserving original mechanics while adapting visuals to and audio to WebAudio for faithful browser playback. Developing web games with Emscripten addresses unique browser constraints, particularly around asset handling and resource limits. Large game assets, such as textures and models, are managed through incremental loading strategies, where files are fetched asynchronously via JavaScript's Fetch API and integrated into the module on demand, minimizing initial download sizes and enabling . Memory management poses another hurdle, as browsers impose sandboxed heaps; Emscripten mitigates this by configurable initial and maximum memory allocations—up to 4GB in supported engines like V8—allowing games to dynamically grow resources without crashing, though careful profiling is required to avoid garbage collection pauses. Performance remains a focus, with recent advancements enabling smooth . Unity's Emscripten pipeline has incorporated optimizations like SIMD instructions and , achieving 60 frames per second in web games through refined output and reduced glue code, as seen in updates from Unity 2021 onward. For computationally intensive titles, Emscripten leverages threads via emulation, partitioning tasks like AI computations and parallel rendering across browser workers to handle complex scenes without bottlenecking the main thread. These features collectively enhance , making Emscripten a robust choice for real-time interactive experiences.

Web Frameworks and Toolkits

Emscripten facilitates the integration of C++ code into frameworks, enabling developers to leverage high-performance native libraries within JavaScript-based environments for interactive applications. One prominent example is its use with Qt, where Emscripten compiles Qt applications to , allowing desktop-like UIs to run in browsers at near-native speeds. This support was introduced in Qt 5.12 and enhanced in Qt 5.13 in 2019, with Emscripten serving as the primary toolchain for building and deploying Qt modules to the web. A key benefit for developers lies in Emscripten's binding mechanisms, particularly Embind, which automatically generates JavaScript wrappers for , functions, and data types, simplifying the creation of hybrid applications that combine C++ performance with flexibility. Embind supports and features, including smart pointers and value semantics, and can produce definitions for seamless integration into modern frameworks like React, where compiled modules are loaded via the standard Module object. This approach reduces and enables natural interoperability, with call overheads around 200 nanoseconds, making it suitable for interactions. In frameworks, Emscripten accelerates .js by compiling the C++-based XNNPACK library to , providing a high-performance backend that outperforms the default implementation. This integration, available since TensorFlow.js 2.1.0 for SIMD support and 2.3.0 for multithreading, delivers up to 10x speedups for models like MobileNet V2, allowing complex inferences to run efficiently in the browser without server dependencies. Emscripten also supports cross-platform development by compiling Node.js addons—typically written in C++ using the Node-API—to WebAssembly equivalents, enabling isomorphic codebases that function in both server and browser contexts. This portability is achieved through Emscripten's Node-API compatibility layer, which allows the same binding code to target native Node.js modules or WebAssembly outputs, facilitating shared logic across environments. Emscripten supports integration with service workers in progressive web apps (PWAs) to cache modules for offline execution, enhancing reliability in data-intensive applications like visualization tools. Developers can further optimize these setups in applications, where Emscripten's outputs run within the engine to deliver native-like performance for compute-heavy desktop web apps.

Software Emulation and Archiving

Emscripten plays a pivotal role in software preservation by enabling the compilation of emulators to WebAssembly, allowing legacy applications to run directly in web browsers without native installations. The Internet Archive's Emularity project, initiated in 2013, exemplifies this application, leveraging Emscripten to port emulators such as DOSBox and MAME for emulating DOS, Amiga, and various console software. These ports, including the em-dosbox variant of DOSBox and JavaScript-compiled MAME, facilitate the execution of historical binaries within a browser environment, supporting formats like .exe files and ROMs. Notable examples include the browser-based emulation of x86 binaries through projects like JSLinux, which compiles the TinyEMU to and using Emscripten, enabling the running of full kernels and applications in the browser. Similarly, the DOSBox-X integrated with Emularity provides emulation for x86-based legacy software, including support for running games and utilities from the era. These implementations allow users to interact with preserved software instantaneously upon loading a webpage, preserving computational history without requiring downloads or setup. The preservation benefits of Emscripten's emulation capabilities are significant, as they enable no-install execution of historical code, democratizing access to software artifacts that might otherwise be inaccessible due to obsolete hardware or operating systems. By compiling emulators to , Emscripten ensures compatibility with modern browsers, supporting direct loading of archived files such as executables and ROM images for educational and purposes. Post-2020 developments have expanded these efforts to include mobile emulation, with ports like DOSBox-X incorporating touch input and responsive interfaces for browser-based access on smartphones and tablets. However, implementing emulation with Emscripten presents challenges, particularly in handling deprecated APIs from legacy systems, which are addressed through polyfills that emulate and other interfaces in the runtime. Additionally, is maintained via WebAssembly's inherent sandboxing model, which isolates emulated code from the host environment, preventing unauthorized access to browser resources or system files during execution. These mechanisms ensure that archived software runs safely, though they require careful configuration to balance fidelity with modern web constraints.

Community and Ecosystem

Integrations and Ports

Emscripten integrates with the System Interface (WASI) to enable execution of compiled binaries in non-browser environments, such as the Wasmtime runtime, by producing WASI-compliant outputs that leverage WASI APIs for system interactions like file I/O. This compatibility allows Emscripten-generated modules to run standalone in WASI-supporting engines without relying on glue code, facilitating server-side and edge deployments. For environments, Emscripten supports execution through generated JavaScript wrappers that interface with Node's built-in APIs, enabling C/C++ code to run efficiently in server-side applications. This integration simplifies embedding Emscripten-compiled modules into projects, with the runtime handling instantiation and via standard constructs. Emscripten has been adapted for experimental ports to embedded systems, including support for the microcontroller through the ESP-IDF framework, where WebAssembly modules can be compiled and executed on resource-constrained hardware. Emscripten collaborates with Rust's wasm-bindgen tool to support polyglot compilation workflows, allowing libraries to interoperate with Emscripten-compiled C/C++ modules by generating compatible bindings and interfaces. This enables mixed-language projects where components can link against Emscripten outputs, streamlining development for targets. In , Emscripten ports to platforms like Workers have advanced by 2025, with templates and runtimes allowing C/C++ code to compile to for low-latency execution at the network edge, including support for WebSockets and serverless functions. These integrations extend Emscripten's reach beyond browsers, powering distributed applications with minimal latency. Third-party tools, such as Emscripten-based SDKs integrated into pipelines, leverage Actions templates to automate compilation and testing of modules across development workflows. These setups install the Emscripten SDK on demand, enabling and deployment of WASM artifacts in continuous integration environments.

Contributing and Support

Contributions to Emscripten are managed through its primary repository at emscripten-core/emscripten, where developers can report bugs, discuss features, and submit changes. The contribution process begins with reviewing open issues on the repository's issue tracker, which serves as the central hub for tracking bugs, feature requests, and enhancements; contributors are encouraged to comment on existing issues before opening new ones to avoid duplication. To submit changes, developers the repository, create a branch for their work, and open a pull request (PR) following the guidelines outlined in the Developer's Guide, which emphasizes writing clear commit messages and ensuring compatibility across supported platforms. A key aspect of the workflow is rigorous testing, particularly verifying that the generated (WASM) outputs function correctly in target environments like modern web browsers, with contributors expected to include test cases or reproduction steps in their PRs to facilitate review. Support for Emscripten users and developers is provided through multiple channels, starting with the comprehensive official documentation hosted at emscripten.org, which covers installation, usage, troubleshooting, and advanced topics. For real-time assistance and discussions, the #emscripten channel on offers a forum for asking questions, sharing ideas, and collaborating on issues, while the emscripten-discuss provides an email-based option for broader announcements and threaded conversations. Additionally, participants in Emscripten often engage at annual summits, such as the WebAssembly Summit series, where ecosystem updates, best practices, and collaborative sessions address toolchains like Emscripten. As an open-source project, Emscripten benefits from community-driven governance through its maintainers and contributors, with funded initiatives like (GSoC) supporting student projects that enhance its capabilities, such as improving filesystem bridges or audio worklet integrations. Maintenance of Emscripten involves regular updates to address security vulnerabilities in dependencies like and ensure compatibility with evolving browser standards, with the 4.0 series released starting in 2024 providing enhanced support as of November 2025. For instance, releases incorporate patches for web-related security concerns and maintain support for recent browser versions, including Chrome 120 and later, allowing seamless execution of compiled WASM modules without deprecated features.

References

  1. https://emscripten.org/
  2. https://github.com/emscripten-core/emscripten
  3. https://dl.acm.org/doi/10.1145/2048147.2048224
  4. https://emscripten.org/docs/introducing_emscripten/about_emscripten.html
  5. https://blog.mozilla.org/blog/2014/03/12/mozilla-and-epic-preview-unreal-engine-4-running-in-firefox/
  6. https://blogs.unity3d.com/2018/08/15/webassembly-is-here/
  7. https://github.com/emscripten-core/emsdk
  8. https://github.com/emscripten-core/emscripten/wiki/Porting-Examples-and-Demos
  9. https://doc.rust-lang.org/rustc/platform-support/wasm32-unknown-emscripten.html
  10. https://hacks.mozilla.org/2011/06/doom-on-the-web/
  11. https://emscripten.org/docs/compiling/WebAssembly.html
  12. https://emscripten.org/docs/porting/emscripten-runtime-environment.html
  13. https://emscripten.org/docs/optimizing/Optimizing-Code.html
  14. https://emscripten.org/docs/porting/simd.html
  15. https://emscripten.org/docs/tools_reference/emcc.html
  16. https://emscripten.org/docs/compiling/Building-Projects.html
  17. https://emscripten.org/docs/compiling/Running-html-files-with-emrun.html
  18. https://github.com/WebAssembly/binaryen
  19. https://emscripten.org/docs/tools_reference/emsdk.html
  20. https://emscripten.org/docs/getting_started/downloads.html
  21. http://mozakai.blogspot.com/2012/02/box2djs-box2d-on-web-is-getting-faster.html
  22. https://hacks.mozilla.org/2012/08/mozilla-and-games-pushing-the-limits-of-whats-possible/
  23. https://emscripten.org/docs/porting/multimedia_and_graphics/OpenGL-support.html
  24. https://github.com/emscripten-core/emscripten/issues/5488
  25. https://news.ycombinator.com/item?id=21808882
  26. https://emscripten.org/docs/porting/pthreads.html
  27. https://github.com/emscripten-core/emscripten/issues/9479
  28. https://emscripten.org/docs/porting/Debugging.html
  29. https://v8.dev/blog/emscripten-llvm-wasm
  30. https://emscripten.org/docs/porting/networking.html
  31. https://emscripten.org/docs/api_reference/Filesystem-API.html
  32. https://emscripten.org/docs/tools_reference/settings_reference.html
  33. https://developer.chrome.com/blog/wasm-debugging-2019
  34. https://emscripten.org/docs/porting/asyncify.html
  35. https://emscripten.org/docs/compiling/Deploying-Pages.html
  36. https://forums.unrealengine.com/t/anyone-interested-in-webgpu-support-for-unreal-engine-5/1910658
  37. https://wiki.qt.io/Qt_for_WebAssembly
  38. https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html
  39. https://blog.tensorflow.org/2020/09/supercharging-tensorflowjs-webassembly.html
  40. https://emscripten.org/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html
  41. https://emscripten.org/docs/api_reference/wasm_workers.html
  42. https://blog.archive.org/2023/09/20/a-quarter-in-a-quarter-million-out-10-years-of-emulation-at-internet-archive/
  43. https://github.com/dreamlayers/em-dosbox
  44. https://github.com/db48x/emularity
  45. https://bellard.org/jslinux/tech.html
  46. https://yksoft1.github.io/dosboxxem-demo/
  47. https://webassembly.org/docs/security/
  48. https://v8.dev/blog/emscripten-standalone-wasm
  49. https://github.com/bytecodealliance/wasmtime/issues/9127
  50. https://nodejs.org/en/learn/getting-started/nodejs-with-webassembly
  51. https://stackoverflow.com/questions/51403326/how-to-use-webassembly-from-node-js
  52. https://github.com/igrr/esp32s2-wasm-demo
  53. https://github.com/rustwasm/wasm-bindgen/issues/1202
  54. https://users.rust-lang.org/t/merging-a-rust-wasm-bindgen-wasm-module-and-an-emscripten-c-module/112786
  55. https://github.com/robertaboukhalil/cf-workers-emscripten
  56. https://blog.cloudflare.com/doom-multiplayer-workers/
  57. https://github.com/marketplace/actions/setup-emscripten-toolchain
  58. https://github.com/numworks/setup-emscripten
  59. https://emscripten.org/docs/contributing/contributing.html
  60. https://emscripten.org/docs/contributing/developers_guide.html
  61. https://emscripten.org/docs/
  62. https://emscripten.org/docs/introducing_emscripten/community.html
  63. https://webassembly.org/community/events/
  64. https://summerofcode.withgoogle.com/archive/2023/projects/4q0L2ZMW
  65. https://summerofcode.withgoogle.com/archive/2022/projects/8aeeJZr6
  66. https://emscripten.org/docs/porting/guidelines/browser_limitations.html
  67. https://github.com/emscripten-core/emscripten/issues/20601
  68. https://github.com/emscripten-core/emscripten/releases
Add your contribution
Related Hubs
User Avatar
No comments yet.