Bilingual

LibreCAD in the Browser
24 days 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.
WATaBoy: JIT-Ing Game Boy Instructions to WASM Beats a Native Interpreter
a month 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.
WASM on the JVM Ships Under the Bytecode Alliance
a month 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.
Lunatic: An Erlang-inspired runtime for WebAssembly
23 days 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.
Wasmer: Fast, secure, lightweight containers based on WebAssembly
23 days 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.
Scheme Is a Hoot
20 days 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.
Show HN: Build offline-first web apps in pure Go and HTML
20 days 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.
Real Linux. In a browser tab. No install. No server. No Docker
20 days 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: Nectar, a Rust-like React that compiles to WebAssembly
19 days 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.
FreeCAD in the Browser
15 days 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.
A pure scheme web programming tool
14 days 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.
We compiled our TypeScript parser to WASM
10 days 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.
Minikotlin
8 days 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.
Show HN: Sidereon: GNSS and Astrodynamics (Python, Rust, JavaScript, C, Elixir)
5 days 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.
GC and Exceptions in Wasmtime
5 days 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.

Hasty Briefsbeta

webassembly

LibreCAD in the Browser

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

WASM on the JVM Ships Under the Bytecode Alliance

Lunatic: An Erlang-inspired runtime for WebAssembly

Wasmer: Fast, secure, lightweight containers based on WebAssembly

Scheme Is a Hoot

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

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

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

FreeCAD in the Browser

A pure scheme web programming tool

We compiled our TypeScript parser to WASM

Minikotlin

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

GC and Exceptions in Wasmtime