LibreOffice, the open-source office suite, is celebrating its 14th anniversary (not 40th) with new features aimed at boosting online collaboration. A key development is the experimental browser-based version using WebAssembly, allowing users to run LibreOffice directly in their browser without installation. This version, dubbed "Zetaoffice," is currently limited but demonstrates the potential for enhanced accessibility and collaborative editing. Further developments include improved real-time collaboration within the desktop suite, progress towards a single, consistent codebase across different platforms, and enhanced interoperability with Microsoft Office formats.
wasmCloud is a platform designed for building and deploying distributed applications using WebAssembly (Wasm) components. It uses a "actor model" and capabilities-based security to orchestrate these Wasm modules across any host environment, from cloud providers to edge devices. The platform handles complex operations like service discovery, networking, and logging, allowing developers to focus solely on their application logic. wasmCloud aims to simplify the process of building portable, secure, and scalable distributed applications with Wasm's lightweight and efficient runtime.
Hacker News users discussed the complexity of WasmCloud's lattice and its potential performance impact. Some questioned the need for such a complex system, suggesting simpler alternatives like a message queue and a registry. Concerns were raised about the overhead of the lattice and its potential to become a bottleneck. Others defended WasmCloud, pointing to its focus on security, actor model, and the benefits of its distributed nature for specific use cases. The use of Smithy IDL also generated discussion, with some finding it overly complex for simple interfaces. Finally, the project's reliance on Rust was noted, with some expressing concern about potential memory management issues and the learning curve associated with the language.
Zeroperl leverages WebAssembly (Wasm) to create a secure sandbox for executing Perl code. It compiles a subset of Perl 5 to Wasm, allowing scripts to run in a browser or server environment with restricted capabilities. This approach enhances security by limiting access to the host system's resources, preventing malicious code from wreaking havoc. Zeroperl utilizes a custom runtime environment built on Wasmer, a Wasm runtime, and focuses on supporting commonly used Perl modules for tasks like text processing and bioinformatics. While not aiming for full Perl compatibility, Zeroperl offers a secure and efficient way to execute specific Perl workloads in constrained environments.
Hacker News commenters generally expressed interest in Zeroperl, praising its innovative approach to sandboxing Perl using WebAssembly. Some questioned the performance implications of this method, wondering if it would introduce significant overhead. Others discussed alternative sandboxing techniques, like using containers or VMs, comparing their strengths and weaknesses to WebAssembly. Several users highlighted potential use cases, particularly for serverless functions and other cloud-native environments. A few expressed skepticism about the viability of fully securing Perl code within WebAssembly given Perl's dynamic nature and CPAN module dependencies. One commenter offered a detailed technical explanation of why certain system calls remain accessible despite the sandbox, emphasizing the ongoing challenges inherent in securing dynamic languages.
The author details their process of creating a WebAssembly (Wasm) virtual machine (VM) written entirely in C. Driven by a desire for a lightweight, embeddable Wasm runtime for resource-constrained environments, they built the VM from scratch, implementing core features like the stack-based execution model, linear memory, and basic WebAssembly System Interface (WASI) support. The project focused on simplicity and understandability over performance, serving primarily as a learning exercise and a platform for experimentation with Wasm. The post walks through key aspects of the VM's design and implementation, including parsing the Wasm binary format, handling function calls, and managing memory. It also highlights the challenges faced and lessons learned during the development process.
Hacker News users generally praised the author's clear writing style and the educational value of the post. Several commenters discussed the project's performance, noting that it's not optimized for speed and suggesting potential improvements like just-in-time compilation. Some shared their own experiences with WASM interpreters and related projects, including comparisons to other implementations and alternative approaches like using a stack machine. Others appreciated the detailed explanation of the parsing and execution process, finding it helpful for understanding WASM internals. A few users pointed out minor corrections or areas for potential enhancement in the code, demonstrating active engagement with the technical details.
Maxima, a powerful computer algebra system (CAS), is now accessible directly in web browsers thanks to a project leveraging Embedded Common Lisp (ECL) compiled to WebAssembly (WasM). This allows users to perform complex symbolic computations, including algebra, calculus, and numerical analysis, without any local installation. The browser-based interface provides a REPL (read-eval-print loop) for interactive calculations and utilizes MathJax for displaying formatted mathematical expressions. This project makes Maxima's capabilities more readily available, eliminating the need for dedicated software or server-side setups.
Commenters on Hacker News express excitement about Maxima running in the browser via WASM and ECL. Several highlight the potential for educational uses and interactive symbolic computation in web environments. Some discuss the performance overhead of WASM and suggest improvements, like pre-compilation for faster startup. The ability to share computational documents easily and integrate with other web technologies is praised. A few users mention other similar projects, including one using ClojureScript and another involving a Python CAS in the browser. The general sentiment is positive, with commenters intrigued by the possibilities this opens up for accessibility and collaborative mathematical work. One commenter expresses interest in building symbolic computation directly into a browser rather than running it as a VM.
WebFFT is a highly optimized JavaScript library for performing Fast Fourier Transforms (FFTs) in web browsers. It leverages SIMD (Single Instruction, Multiple Data) instructions and WebAssembly to achieve speeds significantly faster than other JavaScript FFT implementations, often rivaling native FFT libraries. Designed for real-time audio and video processing, it supports various FFT sizes and configurations, including real and complex FFTs, inverse FFTs, and window functions. The library prioritizes performance and ease of use, offering a simple API for integrating FFT calculations into web applications.
Hacker News users discussed WebFFT's performance claims, with some expressing skepticism about its "fastest" title. Several commenters pointed out that comparing FFT implementations requires careful consideration of various factors like input size, data type, and hardware. Others questioned the benchmark methodology and the lack of comparison against well-established libraries like FFTW. The discussion also touched upon WebAssembly's role in performance and the potential benefits of using SIMD instructions. Some users shared alternative FFT libraries and approaches, including GPU-accelerated solutions. A few commenters appreciated the project's educational value in demonstrating WebAssembly's capabilities.
The blog post showcases an incredibly compact WebAssembly compiler written in just a single tweet's worth of JavaScript code. This compiler takes a simplified subset of C code as input and directly outputs the corresponding WebAssembly binary format. It leverages JavaScript's ability to create typed arrays representing the binary structure of a .wasm file. While extremely limited in functionality (only supporting basic integer arithmetic and a handful of operations), it demonstrates the core principles of converting higher-level code to WebAssembly, offering a concise and educational example of how a compiler operates at its most fundamental level. The author emphasizes this isn't a practical compiler, but rather a fun exploration of code golfing and a digestible introduction to WebAssembly concepts.
Hacker News users generally expressed appreciation for the conciseness and elegance of the WebAssembly compiler presented in the tweet. Several commenters pointed out that while impressive, the compiler is limited and handles only a small subset of WebAssembly. Some discussed the potential educational value of such a minimal example, while others debated the practicality and performance implications. A few users delved into technical details, analyzing the specific instructions and optimizations used. The overall sentiment leaned towards admiration for the technical achievement, tempered with an understanding of its inherent limitations.
Someone has rendered the entirety of the original Doom (1993) game, including all levels, enemies, items, and even the intermission screens, as individual images within a 460MB PDF file. This allows for a static, non-interactive experience of browsing through the game's visuals like a digital museum exhibit. The PDF acts as a unique form of archiving and presenting the game's assets, essentially turning the classic FPS into a flipbook.
Hacker News users generally expressed amusement and appreciation for the novelty of rendering Doom as a PDF. Several commenters questioned the practicality, but acknowledged the technical achievement. Some discussed the technical aspects, wondering how it was accomplished and speculating about the use of vector graphics and custom fonts. Others shared similar projects, like rendering Quake in HTML. A few users pointed out potential issues, such as the large file size and the lack of interactivity, while others jokingly suggested printing it out. Overall, the sentiment was positive, with commenters finding the project a fun and interesting hack.
Summary of Comments ( 51 )
https://news.ycombinator.com/item?id=43038200
HN commenters are generally positive about LibreOffice's continued development and the potential of WebAssembly. Several express excitement about running LibreOffice in the browser, particularly for simplified deployment and access. Some raise concerns about performance and resource usage, especially with complex documents. Others question the practicality of real-time collaboration within a browser-based office suite, comparing it to existing solutions like Google Docs/Sheets. A few commenters delve into technical details, discussing the WASM compilation process and the challenges of porting a large codebase like LibreOffice. There's also discussion about licensing, with some pointing out the limitations of the MPL license in certain commercial scenarios.
The Hacker News discussion on "LibreOffice still kicking at 40, now with browser tricks and real-time collab" contains a moderate number of comments, focusing primarily on the viability and potential of WebAssembly (Wasm) for desktop-grade applications like LibreOffice.
Several commenters express excitement about the possibilities of running complex applications like LibreOffice entirely in the browser, eliminating the need for local installation and offering seamless cross-platform compatibility. This enthusiasm is tempered with pragmatic concerns about performance. Some users question whether Wasm can truly deliver a comparable experience to native applications, particularly for resource-intensive tasks. The discussion touches upon the current state of Wasm performance and anticipates future improvements that could bridge the gap.
A significant thread of conversation revolves around the implications for collaborative editing. Commenters discuss the potential benefits of real-time collaboration within the browser-based version, while also acknowledging the existing collaborative features in the desktop version and questioning the extent to which the Wasm version offers a substantial improvement. Some highlight the complexities of implementing robust and efficient collaborative editing features, and the potential challenges of integrating with existing cloud storage solutions.
Some commenters express skepticism about the overall value proposition of a browser-based LibreOffice. They argue that the need for a full-fledged office suite within the browser is limited, given the availability of lightweight online alternatives like Google Docs. Others counter this argument by emphasizing the importance of offline functionality, data privacy, and the ability to work with complex documents that may not be fully supported by simpler online editors. The open-source nature of LibreOffice is also cited as a significant advantage, allowing for greater flexibility and control compared to proprietary solutions.
The topic of security is also briefly touched upon, with some users raising concerns about the potential vulnerabilities of running complex software within a browser environment.
Finally, a few comments delve into the technical details of the Wasm implementation, discussing the challenges of porting existing C++ code to Wasm and the potential benefits of using technologies like WebGPU for improved performance.