Hasty Briefsbeta

All tags

webassembly

20 stories total

Bilingual

WebKit Features for Safari 26.6
2 months ago
- Safari 26.6 adds a compileOptions parameter to WebAssembly.compileStreaming() and instantiateStreaming(), enabling the use of JS String Builtins with streaming compilation.
- The release includes eight bug fixes across CSS, networking, service workers, web extensions, and WebRTC.
- CSS fixes address issues with the ic length unit scaling, fixed-position elements with position-area, and CSS zoom interactions on iPad.
- Networking fix resolves an issue with deleting partitioned cookies via WKHTTPCookieStore.
- Service worker fixes ensure automatic unregistration for registrations with missing main or imported scripts.
- Web extension fix prevents accumulation of service worker registration database files on Safari launch.
- WebRTC fix corrects ICE candidate gathering failure with iceTransportPolicy: 'relay' on macOS Sequoia.
- Safari 26.6 is available on iOS 26.6, iPadOS 26.6, visionOS 26.6, macOS Tahoe 26.6, macOS Sequoia, and macOS Sonoma.
I hate compilers
2 months ago
- The author discusses the challenges of non-deterministic compiler output, particularly when building WebAssembly from C/C++, citing issues like embedded date/time macros, clang invoking different versions of `wasm-opt`, and address layout dependencies in exception handling.
- To achieve reproducible builds, the author disables address-space randomization and creates architecture-specific SHA256 checksums for both x86_64 and arm64, ensuring at least per-architecture determinism.
- The work is part of implementing a WebAssembly-based proof of work check for Anubis, where the author uses `wasm2js` to recompile WebAssembly to JavaScript for clients with WASM disabled, but faces reproducibility hurdles in compiler toolchain dependencies.
Firefox in WebAssembly
2 months ago
- Firefox has been compiled to WebAssembly using Puter, allowing it to run inside another browser like Chrome.
- The project chose Firefox/Gecko for its strong single-process support.
- An estimated $25,000 worth of Claude Opus and Fable tokens were used, but a Max subscription reduced the actual cost.
- All network traffic is proxied through Puter's server via the WebSocket-based Wisp protocol to bypass browser network restrictions.
- The setup supports end-to-end encryption, verified by inspecting WebSocket messages.
- The code is available in the firefox-wasm repository, and a similar WebKit project exists but lacks a demo.
Porffor: An ahead-of-time JavaScript-to-native/WASM compiler
2 months ago
- Porffor is an ahead-of-time JavaScript compiler that outputs WebAssembly or native binaries, achieving 10-30x smaller and faster WebAssembly output than existing JS-to-Wasm projects by compiling rather than bundling an interpreter.
- JS compiled to Wasm enables sandboxed execution for secure server-side hosting and edge runtimes, with low overhead compared to JITs, allowing more customers on the same hardware.
- Compilation to native binaries reduces sizes up to 1000x (e.g., from ~90MB to <100KB), enabling JS use in embedded systems, game consoles, and tiny CLI apps under 1MB.
- Porffor compiles JS to C then to native, works anywhere C works, and natively supports TypeScript without a build step.
- It is written in JS with 0 eval for safety, performs static analysis for optimizations, and avoids the trade-offs of interpreters or multiple JIT tiers by compiling first and running later.
- Drawbacks include lack of dynamic JS evaluation (like eval) and early-stage incompleteness, but it is tested against the Test262 conformance suite every commit.
Browser-Based QBasic Environment
2 months ago
- This is a QBASIC demo project.
- It contains a single source file: MAIN.BAS.
- The architecture is wasm32, targeting Browser WASI.
- Build steps: Parse QBasic, Lower to KIR, Emit WebAssembly.
- The project name is QBASIC, type is console, entry point is MAIN.BAS.
GC and Exceptions in Wasmtime
2 months ago
- Wasmtime 47 enables Wasm GC and exceptions by default, supporting more languages on WebAssembly.
- Wasm GC eliminates the need for embedded garbage collectors by adding struct/array types and automatic lifecycle management.
- Wasm Exceptions provides efficient try/catch constructs, replacing custom calling conventions and reducing binary size and overhead.
- Wasmtime uses a Cheney-style copying collector with 32-bit GC references based on linear memory for safety and portability.
- Performance is secondary to correctness for now; the collector is optimized for many short-lived Wasm instances.
- Future work includes alias-analysis optimizations and GC integration with the component model via lazy value lowering.
Show HN: Sidereon: GNSS and Astrodynamics (Python, Rust, JavaScript, C, Elixir)
2 months ago
- Sidereon provides a Rust core for GNSS and astrodynamics, including SGP4, SPP/RTK/PPP, RINEX, observation quality control, RTCM/NTRIP streams, frames/time, ionosphere, and conjunction calculations.
- The engine is verified against reference implementations like Vallado, Skyfield, IGS, teqc, and IERS.
- It supports idiomatic interfaces in Rust, Python, C, Elixir, and WebAssembly, with a single verified codebase across languages.
- The engine runs client-side in browsers via WebAssembly, enabling real-time calculations (global coverage, close-approach screening, orbit determination) without server calls.
- Cargo installation is available via 'cargo add sidereon' and crates.io.
Minikotlin
2 months ago
- minikotlin is a compiler written from scratch in C that directly outputs WebAssembly GC bytecode, without relying on JVM, LLVM, Binaryen, or Gradle.
- It compiles Kotlin source code (.kt files) into a running .wasm module entirely within the browser, with the compiler itself available as a WebAssembly module, eliminating the need for external toolchains.
- The compiler supports full Kotlin features including open/override methods, interfaces, data classes, enums, sealed hierarchies with exhaustive when, smart-casting, nullable types with safe calls, generics, extension functions, and coroutines with real suspension via CPS.
- Key compilation techniques include mapping each class to a WebAssembly GC struct type for property storage, implementing virtual dispatch via vtables and call_ref, compiling is checks to ref.test for smart-casting, and lowering coroutine suspension points into continuation closures without Asyncify or threads.
- The system allows writing, compiling, and running Kotlin projects directly in the browser, with features like coroutineScope managing concurrent launches and delay suspending operations handled through host mechanisms like setTimeout.
We compiled our TypeScript parser to WASM
2 months ago
- Encore determines application infrastructure by reading TypeScript code and provisions corresponding resources like APIs, databases, and Pub/Sub topics.
- The parser, written in Rust and compiled to WASM, now runs in browsers, enabling bug reproduction via code snippets and shared links without needing local projects.
- To function in browsers, filesystem dependencies were removed via Cargo features, and in-memory resolution replaces disk operations, with SDK files baked into the WASM binary.
- A playground at tsparser.encore.dev allows testing and sharing parser outputs, ensuring consistency across CLI, CI, and browser environments.
A pure scheme web programming tool
2 months ago
- Goeteia is a Scheme-to-WebAssembly compiler that runs entirely in the browser, using a WebAssembly module (~70 KB gzipped) to recompile source code live.
- It features self-hosting compilation with byte-identical fixpoint verification, efficient runtime with unboxed fixnums and GC-managed data structures, and full Scheme syntax support including macros and hygiene.
- The system includes reactive web libraries for DOM, Three.js, and WebGL, direct-style RPC over HTTP/WebSocket, and supports R6RS-style modules with dead code elimination.
- Goeteia compiles to WebAssembly with GC and tail call support, compatible with modern browsers and runtimes like Node.js and wasmtime, and can be bootstrapped from Chez Scheme.
FreeCAD in the Browser
2 months ago
- LibreCAD and OpenSCAD were compiled to WebAssembly running in browser tabs using a recipe: Qt for WebAssembly, JSPI, a static dependency stack, and audit of threads, filesystems, and OpenGL.
- FreeCAD, a parametric 3D CAD with ~1.5 million lines of C++ and 700k Python, was ported to WebAssembly in ~4 days, running in a browser tab with a first load of ~96 MB compressed.
- The port required building Qt from source with JSPI for modal dialogs, static linking of all modules (no dlopen), and a fixed-function OpenGL emulator for Coin3D's rendering.
- Key challenges included OpenGL emulation, JSPI migration, PySide6 bindings for WebAssembly, and cross-compiling VTK and SMESH for the FEM workbench, with fixes for crashes and performance.
- The port maintains desktop feature parity: 17+ workbenches, Python scripting with PySide6, FEM with real mesh geometry, persistence via IndexedDB, and import/export functionality.
- The engineering was done by Fable (AI), with human direction, bug reporting, and environment setup; full session transcripts and source are available for verification.
Show HN: Nectar, a Rust-like React that compiles to WebAssembly
3 months ago
- Nectar compiles to WebAssembly with a single binary and zero dependencies, running the entire app in WASM while reducing JavaScript to a minimal 10 KB syscall layer.
- One Rust binary handles all development tasks including compilation, formatting, linting, testing, dev server, LSP, package management, and SSR, eliminating toolchain configuration.
- Features O(1) updates per binding without a virtual DOM, ensuring only exact DOM nodes update when signals change, and includes Rust-inspired safety features like a borrow checker and exhaustive pattern matching.
- Eliminates npm, node_modules, webpack, and bundlers by compiling apps to a .wasm binary and a 3 KB runtime, with common web patterns as language primitives.
- The same WASM binary runs on the server via wasmtime with built-in SSR, hydration, and deployment to 29 Cloud Run regions, compiling .nectar source to WebAssembly.
Real Linux. In a browser tab. No install. No server. No Docker
3 months ago
- LinuxOnTab is a browser-based Linux desktop that boots a real x86 kernel and Alpine userland using WebAssembly and v86 emulator, requiring no installation or sign-up.
- It offers full networking via an optional WebSocket backend, allowing TCP egress and port tunneling for SSH, SCP, SFTP, and rsync, with persistent storage via IndexedDB snapshots.
- The tool is sandboxed in the browser, works offline after caching, supports the Alpine package ecosystem, and is ideal for disposable shells, demos, and teaching.
- Key features include Picture-in-Picture mode for floating terminals, URL-driven configuration for demos, and peer-to-peer file sharing via Nostr relays.
- It is a complement to Docker, differing in use cases: LinuxOnTab for quick, ephemeral tasks; Docker for reproducible builds and production.
- Setup involves setting a root password, installing tools, and using scripts for tunneling, enabling direct SSH and file transfers between host and guest.
Show HN: Build offline-first web apps in pure Go and HTML
3 months ago
- Swag allows building offline-first web apps using Go and HTML without JavaScript.
- It compiles Go handlers and templates to WebAssembly, running them in a Service Worker for local execution after first visit.
- Dual deployment: same app serves HTTP requests natively and as WASM for offline use.
- Features include persistent storage, sync, PWA manifest, and cache versioning.
- Reference apps demonstrate real-time markdown preview and offline social feed reading.
Scheme Is a Hoot
3 months ago
- The author is learning Scheme and implementing physics concepts, compiling to the Web using Hoot.
- Hoot is unstable (version 0.9.0), with decent documentation and cryptic errors, but allows Scheme code to run on the Web via custom WASM without Emscripten.
- Initially misunderstood Hoot's compatibility; had to port code to use Hoot-specific functions, then realized it supports more of Guile with manual imports.
- Set up code to run on both native Guile and WASM via Hoot, with automated tests for both environments, making most code agnostic to the runtime.
- Focus has been on backend setup and fundamental physics logic, with progress including a published prototype and source code.
- Future interest includes compiling Zig + Scheme programs to the Web with Hoot, exploring this combination despite potential complexity.
Wasmer: Fast, secure, lightweight containers based on WebAssembly
3 months ago
- Introduces WebAssembly-based container technology for secure and fast application execution across multiple platforms.
- Highlights cost-effective scaling with no overpayment for unused capacity, ensuring effortless traffic management.
- Features include seamless local-to-global deployment, millisecond startup times, built-in security via sandboxing, and flexible SDK support.
Lunatic: An Erlang-inspired runtime for WebAssembly
3 months ago
- Lunatic is an open-source WebAssembly runtime inspired by Erlang.
- It provides isolated, lightweight processes for high concurrency and fault tolerance.
- Features include performance through JIT-compiled Wasm, security via capability limits, and distributed clustering.
- Applications are portable across architectures and OSes, compiled once to WebAssembly.
- Supervision trees enable monitoring and recovery of failing processes.
WASM on the JVM Ships Under the Bytecode Alliance
3 months ago
- Endive 1.0, the pure-Java WebAssembly runtime, has been officially released under the Bytecode Alliance.
- It replaces Chicory with minimal migration, offering the same API and codebase but under new governance.
- New features include full support for WasmGC, enabling integration with languages like Kotlin/Wasm and Dart, and tail call optimizations for improved performance.
- A new library, treesitter4j, compiles tree-sitter and its grammars to Wasm, providing a Java API for parsing various languages without JNI.
- Endive can host Wasm workloads, as demonstrated in a wasmCloud host and Eclipse Vert.x app, and has been stress-tested by running javac and Scala.js as Wasm.
WATaBoy: JIT-Ing Game Boy Instructions to WASM Beats a Native Interpreter
3 months ago
- The project explores using WebAssembly as a target for just-in-time compilation to bypass iOS's JIT restrictions, demonstrating that a Game Boy emulator's JIT-to-Wasm can outperform a native interpreter.
- Implementation involves generating WebAssembly bytecode at runtime in Rust, linking it via JavaScript, and using call_indirect for execution, with benchmarks showing speed improvements of ~1.2x over native interpreters.
- Results indicate cross-browser compatibility with Safari performing best, and future work includes optimizing the PPU emulation and improving code generation tools for broader adoption in emulation.
LibreCAD in the Browser
3 months ago
- The author needed a quick 2D drawing tool accessible in a browser without installation, leading to porting LibreCAD to WebAssembly via AI prompting.
- The port relies on Qt's WebAssembly support and WebAssembly JSPI to handle nested modal dialogs and event loops, which traditional Asyncify couldn't manage.
- Performance optimizations included switching the backing store format to ARGB32 for faster rendering and bundling fonts/patterns for offline use.
- File operations are handled through JavaScript shims and MEMFS, with settings persisted via IndexedDB and exports (PDF, SVG) working via browser downloads.
- The final build is ~18 MB compressed, runs in Chromium-based browsers, and keeps changes minimal behind conditionals to maintain desktop compatibility.

firstprev0next

webassembly

WebKit Features for Safari 26.6

I hate compilers

Firefox in WebAssembly

Porffor: An ahead-of-time JavaScript-to-native/WASM compiler

Browser-Based QBasic Environment

GC and Exceptions in Wasmtime

Show HN: Sidereon: GNSS and Astrodynamics (Python, Rust, JavaScript, C, Elixir)

Minikotlin

We compiled our TypeScript parser to WASM

A pure scheme web programming tool

FreeCAD in the Browser

Show HN: Nectar, a Rust-like React that compiles to WebAssembly

Real Linux. In a browser tab. No install. No server. No Docker

Show HN: Build offline-first web apps in pure Go and HTML

Scheme Is a Hoot

Wasmer: Fast, secure, lightweight containers based on WebAssembly

Lunatic: An Erlang-inspired runtime for WebAssembly

WASM on the JVM Ships Under the Bytecode Alliance

WATaBoy: JIT-Ing Game Boy Instructions to WASM Beats a Native Interpreter

LibreCAD in the Browser