Logo
  • Einführung in Emscripten
    • Über Emscripten
      • Emscripten-Toolchain
      • Code für die Verwendung von Emscripten portieren
    • Community
      • Kontakt aufnehmen
      • Einen Fehler melden
      • Mitwirken
    • Open-Source-Lizenz
    • Versionshinweise
    • Vorträge und Publikationen
      • Präsentationen
      • Fachartikel
      • Bücher
  • Erste Schritte
    • Herunterladen und installieren
      • Installationsanweisungen mit dem emsdk (empfohlen)
        • Emsdk-Installationsziele
        • Plattformspezifische Hinweise
      • Installation überprüfen
      • SDK aktualisieren
      • Emscripten SDK deinstallieren
      • Docker-Image verwenden
      • Installation über inoffizielle Pakete
    • Emscripten-Tutorial
      • Das Wichtigste zuerst
      • Emscripten verifizieren
      • Emscripten ausführen
      • HTML generieren
      • Dateien verwenden
      • Code optimieren
      • Emscripten-Testsuite und Benchmarks
      • Allgemeine Tipps und nächste Schritte
    • Emscripten-Testsuite
      • Einrichtung
      • Tests ausführen
      • Tests überspringen
      • Beenden beim ersten Fehler
      • Ausführen einer Reihe von Zufallstests
      • Wichtige Tests
      • Benchmarking
      • Debugging von Testfehlern
    • Fehlermeldungen
      • LLVM, wasm-ld, clang, Binaryen Fehler
      • Website- und Dokumentationsfehler
    • FAQ (Häufig gestellte Fragen)
      • Wie kompiliere ich Code?
      • Warum erhalte ich Fehler beim Erstellen von Basiscode und Tests?
      • Ich habe etwas ausprobiert: Warum funktioniert es nicht?
      • Muss ich mein Build-System ändern, um Emscripten zu verwenden?
      • Warum ist die Code-Kompilierung langsam?
      • Warum läuft mein Code langsam?
      • Warum ist mein kompilierter Code so groß?
      • Warum erhalte ich beim Kompilieren von Code, der auf einem anderen Rechner funktioniert, Fehler?
      • Wie kann ich die Startzeit verkürzen?
      • Wie betreibe ich einen lokalen Webserver zum Testen / Warum bleibt mein Programm bei „Downloading…“ oder „Preparing…“ hängen?
      • Warum erhalte ich beim Linken machine type must be wasm32 oder unknown file type?
      • Warum schlägt die Kompilierung meines Codes mit einer Fehlermeldung zu Inline-Assembly (oder {"text":"asm"}) fehl?
      • Warum hängt sich meine HTML-App auf?
      • Wie führe ich eine Ereignisschleife (Event Loop) aus?
      • Warum funktioniert meine SDL-App nicht?
      • Wie linke ich gegen Systembibliotheken wie SDL, Boost usw.?
      • Welche Optionen habe ich für die Audiowiedergabe?
      • Wie kann mein kompiliertes Programm auf Dateien zugreifen?
      • Warum kann mein Code nicht auf eine Datei im selben Verzeichnis zugreifen?
      • Wie erkenne ich, wann die Seite vollständig geladen ist und es sicher ist, kompilierte Funktionen aufzurufen?
      • Was bedeutet „exiting the runtime“? Warum werden atexit()s nicht ausgeführt?
      • Warum verschwinden Funktionen in meinem C/C++-Quellcode, wenn ich nach WebAssembly kompiliere?
      • Warum ist die File System API nicht verfügbar, wenn ich mit Closure erstelle?
      • Warum bricht mein Code ab und liefert seltsame Fehler bei der Verwendung von -O2 --closure 1?
      • Warum erhalte ich TypeError: Module.someThing is not a function?
      • Warum existiert Runtime nicht mehr? Warum erhalte ich einen Fehler beim Versuch, auf Runtime.someThing zuzugreifen?
      • Warum erhalte ich einen NameError oder a problem occurred in evaluating content after a "-s", wenn ich eine -s Option verwende?
      • Wie gebe ich -s Optionen in einem CMake-Projekt an?
      • Warum erhalte ich einen Python SyntaxError: invalid syntax bei file=.. oder bei einem String, der mit f'..' beginnt?
      • Warum erhalte ich bei der Optimierung einen Stack-Größenfehler: RangeError: Maximum call stack size exceeded oder ähnlich?
      • Wie übergebe ich int64_t und uint64_t Werte von JS in Wasm-Funktionen?
      • Kann ich mehrere Emscripten-kompilierte Programme auf einer Webseite verwenden?
      • Kann ich JavaScript erstellen, das nur im Web läuft?
      • Woher kommt der seltsame Name für das Projekt?
  • Kompilieren und Ausführen von Projekten
    • Projekte erstellen (Build)
      • Integration in ein Build-System
      • Emscripten Linker-Ausgabedateien
      • Erstellen von Projekten mit Optimierungen
      • Erstellen von Projekten mit Debug-Informationen
      • Bibliotheken verwenden
      • Emscripten Ports
        • Contrib Ports
        • Weitere Ports hinzufügen
        • Externe Ports
      • Build-System Probleme
        • Selbstausführung des Build-Systems
        • Faux Dynamisches Linken
        • Configure führt möglicherweise Prüfungen aus, die scheinbar fehlschlagen
        • Archivdateien (.a)
      • Manuelle Verwendung von emcc
      • Erkennung von Emscripten im Präprozessor
      • Verwendung eines Compiler-Wrappers
      • pkg-config
      • Beispiele / Testcode
      • Fehlerbehebung
    • Kompilieren nach WebAssembly
      • Einrichtung
        • Backends
      • Trapping
      • Compiler-Ausgabe
      • WebAssembly-Unterstützung in Browsern
      • .wasm Dateien und Kompilierung
      • Webserver-Einrichtung
    • Dynamisches Linken
      • Hintergrund
      • Übersicht über dynamisches Linken
      • Praktische Details
        • Dynamisches Linken zur Ladezeit
        • Dynamisches Linken zur Laufzeit mit dlopen()
      • Code-Größe
      • Systembibliotheken
      • Verschiedene Hinweise
        • Dynamische Prüfungen
        • Einschränkungen
        • Pthreads-Unterstützung
    • Ausführen von HTML-Dateien mit emrun
      • Funktionen
      • Kurze Anleitung
      • Wahl des auszuführenden Browsers
      • Sicherheitsauswirkungen
      • Steuerung des Webserver-Betriebs
      • Steuerung der Protokollausgabe
      • Aufräumen nach der Ausführung
      • Webseiten in Firefox ausführen
      • Webseiten auf einem Android-Gerät ausführen
    • Bereitstellung von Emscripten-kompilierten Seiten
      • Build-Dateien und benutzerdefinierte Shell
      • Optimierung der Download-Größen
      • Optimierung der Seitenstartzeiten
      • Bereitstellung eines schnellen zweiten Ladevorgangs
      • Reservieren von Speicher für kompilierten Code
      • Robuste Fehlerbehandlung
      • Vorbereitung auf die Web-Umgebung
    • Bauen und Bereitstellen auf GitLab
      • Eine beispielhafte .gitlab-ci.yml
    • Emscripten Contrib Ports
      • contrib.glfw3
  • Portierung
    • Code-Portabilität und Einschränkungen
      • Richtlinien zur Portabilität
        • Aktuelle Web-Einschränkungen
        • Code, der nicht kompiliert werden kann
        • Code, der kompiliert, aber langsam laufen könnte
        • Weitere Probleme
      • API-Einschränkungen
        • Netzwerk
        • Dateisysteme
        • Anwendungs-Hauptschleife
        • Weitere APIs
      • Funktionszeiger-Probleme
        • Debugging von Funktionszeiger-Problemen
        • Umgehung von Funktionszeiger-Problemen
      • Spezifische Browser-Einschränkungen
    • Emscripten Laufzeitumgebung
      • Eingabe/Ausgabe
      • Dateisysteme
      • Browser-Hauptschleife
        • Implementierung einer asynchronen Hauptschleife in C/C++
        • Verwendung von Asyncify zum Zurückgeben der Kontrolle an den Browser
      • Ausführungslebenszyklus
      • Speicherdarstellung in Emscripten
    • Verbindung von C++ und JavaScript
      • Interaktion mit Code
        • Aufrufen kompilierter C-Funktionen aus JavaScript mit ccall/cwrap
        • Interaktion mit einer in C/C++ geschriebenen API aus NodeJS
        • Kompilierten C/C++ Code „direkt“ aus JavaScript aufrufen
        • Aufrufen von JavaScript aus C/C++
        • Implementierung einer C-API in JavaScript
        • Aufrufen von JavaScript-Funktionen als Funktionszeiger aus C
        • Funktionssignaturen
        • Speicherzugriff aus JavaScript
        • Beeinflussung des Ausführungsverhaltens
        • Umgebungsvariablen
        • Bindung von C++ und JavaScript — WebIDL Binder und Embind
        • Bindung von C/C++ und JavaScript - Node-API
      • Embind
        • Ein kurzes Beispiel
        • Bindung von Bibliotheken
        • Klassen
        • Speichermanagement
        • Wertetypen
        • Fortgeschrittene Klassenkonzepte
        • Überladene Funktionen
        • Enums
        • Konstanten
        • Klasseneigenschaften
        • Memory Views
        • Verwendung von val zur Transliteration von JavaScript nach C++
        • Eingebaute Typkonvertierungen
        • TypeScript-Definitionen
        • Leistung
      • WebIDL Binder
        • Ein kurzes Beispiel
        • Modulare Ausgabe
        • Verwendung von C++-Klassen in JavaScript
        • Attribute
        • Pointer, Referenzen, Wertetypen (Ref und Value)
        • Const
        • Nicht-löschbare Klassen (NoDelete)
        • Definition von inneren Klassen und Klassen innerhalb von Namespaces (Prefix)
        • Operatoren
        • enums
        • Unterklassenbildung von C++-Basisklassen in JavaScript (JSImplementation)
        • Pointer und Vergleiche
        • NULL
        • void*
        • WebIDL-Typen
        • Test- und Beispielcode
    • Dateien und Dateisysteme
      • Dateisystem-Übersicht
        • Emscripten Dateisystem-Laufzeitumgebung
        • Emscripten Dateisystem-Architektur
      • Dateien verpacken
        • Verpacken mit emcc
        • Verpacken mit dem File-Packager-Tool
        • Ändern des Speicherorts der Datendatei
        • Modifizieren von Datei-Speicherorten im virtuellen Dateisystem
        • Gültiger Zeichensatz
        • Überwachung der Dateinutzung
        • Dateien vorladen
        • Testcode
      • Verwendung des synchronen virtuellen XHR-gestützten Dateisystems
        • Testcode
        • Anweisungen
    • Multimedia und Grafik
      • EGL-Unterstützung in Emscripten
        • Was EGL nicht ist?
        • Wie erstellt man einen WebGL-Kontext mit EGL?
        • Implementierungsstatus und Hinweise
      • OpenGL-Unterstützung in Emscripten
        • WebGL-freundliche Untermenge von OpenGL ES 2.0/3.0
        • OpenGL ES 2.0/3.0 Emulation
        • Emulation älterer Desktop-OpenGL-API-Funktionen
        • OpenGL ES Erweiterungen
        • Testcode/Beispiele
        • Fehlerberichte
    • Audio
      • Unterstützte OpenAL-Erweiterungen
      • Richtlinien für Audio in Emscripten
      • Emscripten-spezifisches Aufnahmeverhalten
      • Nützliche Implementierungsdetails der OpenAL-Aufnahme
      • Verbesserung und Erweiterung der Implementierung
    • Debugging
      • Debugging im Browser
      • Debug-Modus (EMCC_DEBUG)
      • Compiler-Einstellungen
      • Sanitizers
      • emcc ausführliche Ausgabe (verbose)
      • Manuelles Print-Debugging
      • Debugging mit Chrome Devtools
      • Behandlung von C++-Exceptions aus JavaScript
      • Emscripten-spezifische Probleme
        • Speicherausrichtung-Probleme (Alignment)
        • Funktionszeiger-Probleme
        • Endlosschleifen
      • Profiling
        • Geschwindigkeit
        • Speicher
      • AutoDebugger
        • AutoDebugger Regression Workflow
      • Nützliche Links
      • Brauchen Sie Hilfe?
    • Pthreads-Unterstützung
      • Kompilieren mit aktivierten Pthreads
      • Zusätzliche Flags
      • Proxying
      • Blockieren des Browser-Hauptthreads
      • Besondere Überlegungen
      • Leistung des Allokators
      • Ausführen von Code und Tests
    • Netzwerk
      • Emscripten WebSockets API
      • Emulierte POSIX TCP Sockets über WebSockets
      • Vollständige POSIX Sockets über WebSocket Proxy Server
      • XmlHttpRequests und Fetch API
      • WebRTC und UDP
    • Verwendung von SIMD mit WebAssembly
    • GCC/Clang SIMD Vektorerweiterungen
    • WebAssembly SIMD Intrinsics
    • Einschränkungen und Verhaltensunterschiede
    • Optimierungsüberlegungen
    • Kompilieren von SIMD-Code für x86 SSE* Befehlssätze
    • Kompilieren von SIMD-Code für den ARM NEON Befehlssatz
    • Unterstützung für C++ Exceptions
      • Emscripten (JavaScript-basierte) Exception-Unterstützung
      • WebAssembly Exception Handling-basierte Unterstützung
      • Debugging von Exceptions
        • Stack Traces
        • Behandlung von C++-Exceptions aus JavaScript
      • Gemeinsame Verwendung von Exceptions und setjmp-longjmp
    • C setjmp-longjmp Unterstützung
      • JavaScript-basierte setjmp-longjmp Unterstützung
      • WebAssembly Exception Handling-basierte setjmp-longjmp Unterstützung
      • Gemeinsame Verwendung von Exceptions und setjmp-longjmp
    • Asynchroner Code
      • Schlafen / Kontrolle an die Ereignisschleife abgeben
      • Asynchrone Web-APIs so verhalten lassen, als wären sie synchron
      • Möglichkeiten zur Nutzung von Asyncify-APIs in älteren Engines
      • Mehr zu ASYNCIFY_IMPORTS
      • Asyncify mit dynamischem Linken
      • Verwendung mit Embind
      • Verwendung mit ccall
      • Unterschiede zwischen Asyncify und JSPI
      • Optimierung von Asyncify
      • Potenzielle Probleme
        • Stack-Überläufe (Asyncify)
        • Reeintranz
        • Beginn des Rückspulens mit kompiliertem Code auf dem Stack (Asyncify)
      • Migration von älteren Asyncify-APIs
    • Projekte erstellen (Build)
      • Integration in ein Build-System
      • Emscripten Linker-Ausgabedateien
      • Erstellen von Projekten mit Optimierungen
      • Erstellen von Projekten mit Debug-Informationen
      • Bibliotheken verwenden
      • Emscripten Ports
        • Contrib Ports
        • Weitere Ports hinzufügen
        • Externe Ports
      • Build-System Probleme
        • Selbstausführung des Build-Systems
        • Faux Dynamisches Linken
        • Configure führt möglicherweise Prüfungen aus, die scheinbar fehlschlagen
        • Archivdateien (.a)
      • Manuelle Verwendung von emcc
      • Erkennung von Emscripten im Präprozessor
      • Verwendung eines Compiler-Wrappers
      • pkg-config
      • Beispiele / Testcode
      • Fehlerbehebung
  • API-Referenz
    • emscripten.h
      • Inline-Assembly/JavaScript
        • Defines
      • Aufrufen von JavaScript aus C/C++
        • Funktionszeigertypen für Callbacks
        • Funktionen
      • Browser-Ausführungsumgebung
        • Funktionen
      • Asynchrone Dateisystem-API
        • Typedefs
        • Funktionen
      • Asynchrone IndexedDB-API
      • Kompilieren
      • Worker-API
        • Typedefs
        • Funktionen
      • Logging-Utilities
        • Defines
        • Funktionen
      • Registrierung von Socket-Ereignissen
        • Callback-Funktionen
        • Funktionen
      • Nicht ausgerichtete Typen (Unaligned)
        • Typedefs
      • Pseudo-synchrone Funktionen
        • Schlafen (Sleeping)
        • Netzwerk
        • IndexedDB
      • Asyncify-Funktionen
        • Typedefs
        • Funktionen
      • ABI-Funktionen
    • html5.h
      • Wie man diese API verwendet
        • Registrierungsfunktionen
        • Callback-Funktionen
        • Von Websicherheit betroffene Funktionen
        • Test/Beispielcode
      • Allgemeine Typen
      • Funktionsergebniswerte
      • Tasten (Keys)
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Maus
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Mausrad
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Benutzeroberfläche (UI)
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Fokus
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Geräteausrichtung
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Gerätebewegung
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Orientierung
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Vollbild
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Mauszeigersperre (Pointerlock)
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Sichtbarkeit
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Touch
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Gamepad
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Batterie
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • Vibration
        • Funktionen
      • Seitenentladung (Page unload)
        • Defines
        • Callback-Funktionen
        • Funktionen
      • WebGL-Kontext
        • Defines
        • Strukturen
        • Callback-Funktionen
        • Funktionen
      • CSS
        • Funktionen
      • Animation und Timing
        • Funktionen
      • Throw
        • Funktionen
    • console.h
      • Funktionen
    • preamble.js
      • Aufrufen kompilierter C-Funktionen aus JavaScript
      • Speicherzugriff
      • Konvertierungsfunktionen — Strings, Pointer und Arrays
      • Laufzeitabhängigkeiten
      • Stack Trace
      • Typ-Accessoren für das Speichermodell
    • Dateisystem-API
      • Neues Dateisystem: WasmFS
      • Einschließen der Dateisystemunterstützung
      • Persistente Daten
      • Dateisysteme
        • MEMFS
        • NODEFS
        • NODERAWFS
        • IDBFS
        • WORKERFS
        • PROXYFS
      • Geräte
      • Einrichten von Standard-E/A-Geräten
      • Dateisystem-API
      • Dateitypen
      • Pfade
    • Fetch-API
      • Einführung
      • Daten persistieren
        • Daten-Bytes aus dem Speicher persistieren
        • Löschen einer Datei aus IndexedDB
      • Synchrone Abrufe (Fetches)
      • Fortschritt verfolgen
      • Verwalten großer Dateien
        • Direktes Herunterladen in die IndexedDB
        • Streaming-Downloads
        • Byte-Bereichs-Downloads
      • TODO Dokumentieren
    • Module-Objekt
      • Erstellen des Module-Objekts
      • Kompilierungseinstellungen
      • Beeinflussung der Ausführung
      • Weitere Methoden
    • val.h
    • bind.h (in Arbeit)
      • Wie man diese API verwendet
        • Defines
      • Richtlinien (Policies)
      • select_overload und select_const
      • Funktionen
      • Value Tuples
      • Value Structs
      • Smart Pointer
      • Klassen
      • Vektoren
      • Maps
      • Enums
      • Konstanten
    • trace.h
      • Verwendung
        • Compiler-Interaktion
        • Initialisierung und Abbau
        • Kontexte
        • Frames
        • Kommentierung von Allokationen
        • Gesamte Speichernutzung
        • Protokollieren von Nachrichten
        • Aufgaben
        • Fehler melden
      • Betrieb des Servers
      • Design-Hinweise
        • Client/Server-Design
        • Daten-Batching
        • Heap nicht stören
      • Funktionen
    • fiber.h
      • API-Referenz
        • Typen
        • Funktionen
    • proxying.h
      • API-Referenz
        • Typen
        • Funktionen
        • C++ API
    • stack.h
    • Wasm Workers API
      • Kurzes Beispiel
      • Einführung
      • Pthreads vs. Wasm Workers: Was soll man verwenden?
        • Pthreads können JS-Funktionen proxien
        • Pthreads haben Unterbrechungspunkte (Cancellation Points)
        • Pthreads können synchron starten - Wasm Workers starten immer asynchron
        • Pthread-Topologie ist flach - Wasm Workers sind hierarchisch
        • Pthreads können die Wasm Worker Synchronisations-API nutzen, aber nicht umgekehrt
        • Pthreads haben eine „Thread Main“-Funktion und atexit-Handler
        • Pthreads haben eine Proxy-Nachrichtenwarteschlange pro Thread, Wasm Workers nicht
        • Pthreads synchronisieren die Echtzeit (Wallclock Time)
        • Eingabeereignis-API proxiet nur zu Pthreads zurück
        • Unterschiede in der Implementierung von Pthread vs. emscripten_lock
        • Speicheranforderungen
        • Generierte Codegröße
        • API-Unterschiede
      • Überlegungen zur Stackgröße von Wasm Workers
      • Wasm Workers vs. die frühere Emscripten Worker API
      • Einschränkungen
      • Beispielcode
    • Wasm Audio Worklets API
      • Entwicklungsübersicht
      • Programmierbeispiel
      • Synchronisierung des Audio-Threads mit dem Hauptthread
      • Weitere Beispiele
    • Fortgeschrittene APIs
      • settings.js
      • preamble.js
      • Erweiterte Dateisystem-API
  • Werkzeug-Referenz
    • Emscripten SDK (emsdk)
      • Kommandozeilensyntax
        • Argumente
        • Tools und SDK-Ziele
      • SDK-Konzepte
      • Emscripten Compiler-Konfigurationsdatei (.emscripten)
      • „How-to“-Anleitungen
        • Wie erhalte ich einfach das neueste SDK?
        • Wie verwende ich emsdk?
        • Wie überprüfe ich, welche Versionen des SDK und der Tools installiert sind?
        • Wie installiere ich eine Tool/SDK-Version?
        • Wie entferne ich ein Tool oder ein SDK?
        • Wie suche ich nach Updates für das Emscripten SDK?
        • Wie ändere ich die aktuell aktive SDK-Version?
        • Wie installiere und aktiviere ich alte Emscripten SDKs und Tools?
        • Wie verfolge ich die neuesten Änderungen am SDK?
        • Wie verwende ich meinen eigenen Emscripten-Fork mit dem SDK?
    • Emscripten Compiler Frontend (emcc)
      • Kommandozeilensyntax
        • Argumente
      • Umgebungsvariablen
    • Emscripten Windows-Eingabeaufforderung (emcmdprompt.bat)
      • Kommandozeilensyntax
    • Emscripten Compiler-Einstellungen
      • ASSERTIONS
      • STACK_OVERFLOW_CHECK
      • CHECK_NULL_WRITES
      • VERBOSE
      • INVOKE_RUN
      • EXIT_RUNTIME
      • STACK_SIZE
      • MALLOC
      • ABORTING_MALLOC
      • INITIAL_HEAP
      • INITIAL_MEMORY
      • MAXIMUM_MEMORY
      • ALLOW_MEMORY_GROWTH
      • MEMORY_GROWTH_GEOMETRIC_STEP
      • MEMORY_GROWTH_GEOMETRIC_CAP
      • MEMORY_GROWTH_LINEAR_STEP
      • MEMORY64
      • INITIAL_TABLE
      • ALLOW_TABLE_GROWTH
      • GLOBAL_BASE
      • TABLE_BASE
      • USE_CLOSURE_COMPILER
      • CLOSURE_WARNINGS
      • IGNORE_CLOSURE_COMPILER_ERRORS
      • DECLARE_ASM_MODULE_EXPORTS
      • INLINING_LIMIT
      • SUPPORT_BIG_ENDIAN
      • SAFE_HEAP
      • SAFE_HEAP_LOG
      • EMULATE_FUNCTION_POINTER_CASTS
      • EXCEPTION_DEBUG
      • DEMANGLE_SUPPORT
      • LIBRARY_DEBUG
      • SYSCALL_DEBUG
      • SOCKET_DEBUG
      • DYLINK_DEBUG
      • FS_DEBUG
      • SOCKET_WEBRTC
      • WEBSOCKET_URL
      • PROXY_POSIX_SOCKETS
      • WEBSOCKET_SUBPROTOCOL
      • OPENAL_DEBUG
      • WEBSOCKET_DEBUG
      • GL_ASSERTIONS
      • TRACE_WEBGL_CALLS
      • GL_DEBUG
      • GL_TESTING
      • GL_MAX_TEMP_BUFFER_SIZE
      • GL_UNSAFE_OPTS
      • FULL_ES2
      • GL_EMULATE_GLES_VERSION_STRING_FORMAT
      • GL_EXTENSIONS_IN_PREFIXED_FORMAT
      • GL_SUPPORT_AUTOMATIC_ENABLE_EXTENSIONS
      • GL_SUPPORT_SIMPLE_ENABLE_EXTENSIONS
      • GL_TRACK_ERRORS
      • GL_SUPPORT_EXPLICIT_SWAP_CONTROL
      • GL_POOL_TEMP_BUFFERS
      • GL_EXPLICIT_UNIFORM_LOCATION
      • GL_EXPLICIT_UNIFORM_BINDING
      • USE_WEBGL2
      • MIN_WEBGL_VERSION
      • MAX_WEBGL_VERSION
      • WEBGL2_BACKWARDS_COMPATIBILITY_EMULATION
      • FULL_ES3
      • LEGACY_GL_EMULATION
      • GL_FFP_ONLY
      • GL_PREINITIALIZED_CONTEXT
      • USE_WEBGPU
      • STB_IMAGE
      • GL_DISABLE_HALF_FLOAT_EXTENSION_IF_BROKEN
      • GL_WORKAROUND_SAFARI_GETCONTEXT_BUG
      • GL_ENABLE_GET_PROC_ADDRESS
      • JS_MATH
      • POLYFILL_OLD_MATH_FUNCTIONS
      • LEGACY_VM_SUPPORT
      • ENVIRONMENT
      • LZ4
      • DISABLE_EXCEPTION_CATCHING
      • EXCEPTION_CATCHING_ALLOWED
      • DISABLE_EXCEPTION_THROWING
      • EXPORT_EXCEPTION_HANDLING_HELPERS
      • EXCEPTION_STACK_TRACES
      • WASM_EXNREF
      • NODEJS_CATCH_EXIT
      • NODEJS_CATCH_REJECTION
      • ASYNCIFY
      • ASYNCIFY_IMPORTS
      • ASYNCIFY_IGNORE_INDIRECT
      • ASYNCIFY_STACK_SIZE
      • ASYNCIFY_REMOVE
      • ASYNCIFY_ADD
      • ASYNCIFY_PROPAGATE_ADD
      • ASYNCIFY_ONLY
      • ASYNCIFY_ADVISE
      • ASYNCIFY_LAZY_LOAD_CODE
      • ASYNCIFY_DEBUG
      • ASYNCIFY_EXPORTS
      • JSPI
      • JSPI_EXPORTS
      • JSPI_IMPORTS
      • EXPORTED_RUNTIME_METHODS
      • EXTRA_EXPORTED_RUNTIME_METHODS
      • INCOMING_MODULE_JS_API
      • CASE_INSENSITIVE_FS
      • FILESYSTEM
      • FORCE_FILESYSTEM
      • NODERAWFS
      • NODE_CODE_CACHING
      • EXPORTED_FUNCTIONS
      • EXPORT_ALL
      • EXPORT_KEEPALIVE
      • RETAIN_COMPILER_SETTINGS
      • DEFAULT_LIBRARY_FUNCS_TO_INCLUDE
      • INCLUDE_FULL_LIBRARY
      • RELOCATABLE
      • MAIN_MODULE
      • SIDE_MODULE
      • RUNTIME_LINKED_LIBS
      • BUILD_AS_WORKER
      • PROXY_TO_WORKER
      • PROXY_TO_WORKER_FILENAME
      • PROXY_TO_PTHREAD
      • LINKABLE
      • STRICT
      • IGNORE_MISSING_MAIN
      • STRICT_JS
      • WARN_ON_UNDEFINED_SYMBOLS
      • ERROR_ON_UNDEFINED_SYMBOLS
      • SMALL_XHR_CHUNKS
      • HEADLESS
      • DETERMINISTIC
      • MODULARIZE
      • EXPORT_ES6
      • USE_ES6_IMPORT_META
      • EXPORT_NAME
      • DYNAMIC_EXECUTION
      • BOOTSTRAPPING_STRUCT_INFO
      • EMSCRIPTEN_TRACING
      • USE_GLFW
      • WASM
      • STANDALONE_WASM
      • BINARYEN_IGNORE_IMPLICIT_TRAPS
      • BINARYEN_EXTRA_PASSES
      • WASM_ASYNC_COMPILATION
      • DYNCALLS
      • WASM_BIGINT
      • EMIT_PRODUCERS_SECTION
      • EMIT_EMSCRIPTEN_LICENSE
      • LEGALIZE_JS_FFI
      • USE_SDL
      • USE_SDL_GFX
      • USE_SDL_IMAGE
      • USE_SDL_TTF
      • USE_SDL_NET
      • USE_ICU
      • USE_ZLIB
      • USE_BZIP2
      • USE_GIFLIB
      • USE_LIBJPEG
      • USE_LIBPNG
      • USE_REGAL
      • USE_BOOST_HEADERS
      • USE_BULLET
      • USE_VORBIS
      • USE_OGG
      • USE_MPG123
      • USE_FREETYPE
      • USE_SDL_MIXER
      • USE_HARFBUZZ
      • USE_COCOS2D
      • USE_MODPLUG
      • SDL2_IMAGE_FORMATS
      • SDL2_MIXER_FORMATS
      • USE_SQLITE3
      • SHARED_MEMORY
      • WASM_WORKERS
      • AUDIO_WORKLET
      • WEBAUDIO_DEBUG
      • PTHREAD_POOL_SIZE
      • PTHREAD_POOL_SIZE_STRICT
      • PTHREAD_POOL_DELAY_LOAD
      • DEFAULT_PTHREAD_STACK_SIZE
      • PTHREADS_PROFILING
      • ALLOW_BLOCKING_ON_MAIN_THREAD
      • PTHREADS_DEBUG
      • EVAL_CTORS
      • TEXTDECODER
      • EMBIND_STD_STRING_IS_UTF8
      • EMBIND_AOT
      • OFFSCREENCANVAS_SUPPORT
      • OFFSCREENCANVASES_TO_PTHREAD
      • OFFSCREEN_FRAMEBUFFER
      • FETCH_SUPPORT_INDEXEDDB
      • FETCH_DEBUG
      • FETCH
      • WASMFS
      • SINGLE_FILE
      • AUTO_JS_LIBRARIES
      • AUTO_NATIVE_LIBRARIES
      • MIN_FIREFOX_VERSION
      • MIN_SAFARI_VERSION
      • MIN_CHROME_VERSION
      • MIN_NODE_VERSION
      • SUPPORT_ERRNO
      • MINIMAL_RUNTIME
      • MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION
      • MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION
      • SUPPORT_LONGJMP
      • DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR
      • HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS
      • MINIFY_HTML
      • MAYBE_WASM2JS
      • ASAN_SHADOW_SIZE
      • USE_OFFSET_CONVERTER
      • LOAD_SOURCE_MAP
      • DEFAULT_TO_CXX
      • PRINTF_LONG_DOUBLE
      • SEPARATE_DWARF_URL
      • ERROR_ON_WASM_CHANGES_AFTER_LINK
      • ABORT_ON_WASM_EXCEPTIONS
      • PURE_WASI
      • IMPORTED_MEMORY
      • SPLIT_MODULE
      • AUTOLOAD_DYLIBS
      • ALLOW_UNIMPLEMENTED_SYSCALLS
      • TRUSTED_TYPES
      • POLYFILL
      • RUNTIME_DEBUG
      • LEGACY_RUNTIME
      • SIGNATURE_CONVERSIONS
  • Code optimieren
    • Wie man Code optimiert
    • Wie Emscripten optimiert
    • Link-Zeiten
    • Erweiterte Compiler-Einstellungen
    • WebAssembly
    • Code-Größe
      • Abwägung zwischen Code-Größe und Leistung
      • Verschiedene Tipps zur Code-Größe
    • LTO (Link Time Optimization)
    • EVAL_CTORS
    • Sehr große Codebasen
      • Eigenständige Ausführung (Running by itself)
      • Modul-Splitting
    • Andere Optimierungsprobleme
      • C++ Exceptions
      • C++ RTTI
      • Speicherwachstum
      • Anzeigen von Code-Optimierungsschritten
      • Allokation
    • Unsichere Optimierungen
    • Profiling
    • Fehlersuche bei schlechter Leistung
  • WebGL optimieren
    • Welchen GL-Modus anvisieren?
    • Wie man WebGL profilt
    • Redundante Aufrufe vermeiden
    • Techniken zur Minimierung von API-Aufrufen
    • Vermeidung von GPU-CPU-Synchronisationspunkten
    • GPU-Treiber-freundliches Speicherzugriffsverhalten
    • Wenn die GPU der Flaschenhals ist
    • Optimierung von Ladezeiten und andere bewährte Praktiken
    • Migration auf WebGL 2
  • Debugging mit Sanitizers
    • Undefined Behaviour Sanitizer
      • Abfangen von Null-Dereferenzierung
      • Minimal Runtime
    • Address Sanitizer
      • Beispiele
        • Pufferüberlauf (Buffer Overflow)
        • Use After Free
        • Speicherlecks (Memory Leaks)
        • Use After Return
      • Konfiguration
        • Deaktivieren von malloc/free Stack Traces
      • Vergleich mit SAFE_HEAP
  • Emscripten aus dem Quellcode erstellen
    • LLVM bauen
    • Binaryen bauen
      • Anforderungen an die Emscripten-Toolchain
        • Was Sie benötigen
        • Testen, welche Tools installiert sind
      • Konfiguration der Emscripten-Einstellungen beim manuellen Bauen aus dem Quellcode
        • Erstellen der Compiler-Konfigurationsdatei
        • Lokalisieren der Compiler-Konfigurationsdatei (.emscripten)
        • Format der Compiler-Konfigurationsdatei
        • Bearbeiten der Compiler-Konfigurationsdatei
      • Überprüfung der Emscripten-Entwicklungsumgebung
        • Testen der Umgebung
        • Fehlerbehebung
  • Beitrag zu Emscripten leisten
    • Mitwirken
      • Erste Schritte
      • Nächste Schritte
    • Entwickler-Leitfaden
      • Einrichtung
      • Interessante Repositories und Branches
      • Patches einreichen
      • Code-Reviews
      • Compiler-Übersicht
      • Emscripten-Testsuite
      • Bisecting (Fehlersuche durch Eingrenzung)
      • Arbeiten mit C-Strukturen und Defines
      • Siehe auch
    • AUTOREN
  • Profiling der Toolchain
    • Kurzes Beispiel
    • Details
      • Befehle des Profiling-Tools
    • Instrumentierung von Python-Skripten
      • Python Profiling-Blöcke
  • Über diese Website
    • Website durchsuchen
    • Fehler melden
    • Beitrag zur Website leisten
    • Bauen der Website
      • Installation von Sphinx
      • Website-Builds
      • SDK-Builds
      • Build-Version
    • Schreiben und Aktualisieren von Artikeln
      • Styleguide
      • Wie man auf ein Dokument oder eine Überschrift verlinkt
      • Empfohlenes Markup für Abschnitte/Überschriften
      • Arbeiten mit Markdown
    • „Read the Docs“-Theme
    • Website-Lizenz
Index
 
Logo
Fork me on GitHub
  • DocsDokumentation
  • SDKDownloads
  • HilfeCommunity
  • GitHub
Home
» Seitenlinks

Seitenlinks¶

Dieser Abschnitt enthält Artikel, die spezifisch für die Seite sind oder in keine andere Kategorie gehören.

  • Über diese Website
  • Glossar
Fehler meldenFehler melden LizenzierungLizenzierung BeitragenBeitragen MailinglisteMailingliste WikiWiki VersionshinweiseVersionshinweise BlogsBlogs HilfeKontakt
  • Über die Website
  • Seitenfehler

© Copyright 2015, Emscripten-Mitwirkende.