Six megabytes. That is the complete size of a desktop app built with TinyJS, smaller than a single RAW photo from a smartphone. For comparison: an empty Electron app weighs in at a minimum of 150 megabytes just from the bundled Chromium and Node.js, before a single line of custom code has even been written. This gap is exactly why TinyJS, a project unveiled on October 12, 2026 by The Register and built by developer Tarwin Stroh-Spijer, is turning heads in the JavaScript community.
TinyJS positions itself as a serious Electron alternative for developers who want to build cross-platform desktop applications without dragging along an entire browser engine. The open-source framework pairs a tiny JavaScript runtime with the operating system’s own native webview, promising the best of both worlds: web technologies and genuinely lightweight footprints.
Table of Contents
Key Takeaways
- TinyJS is a new, open-source framework (MIT license) for desktop apps on macOS, Windows, and Linux, released by Tarwin Stroh-Spijer.
- The architecture strictly separates the backend (txiki.js, roughly 5.6 MB) from the frontend (the native system webview) and connects the two via a local Unix socket or a named pipe, not HTTP.
- Finished TinyJS apps weigh in at around 6 MB according to the project’s own website, compared to at least 150 MB for Electron, roughly 10 MB for Tauri, and roughly 3 MB for Neutralino.
- macOS is considered stable; Windows and Linux are currently in beta.
- Developers can work with familiar HTML, CSS, and JavaScript, including WebGPU support and Vite templates for React, Vue, Svelte, Solid, Preact, Lit, and Alpine.
What exactly is TinyJS?
TinyJS is a framework for building standalone desktop applications out of web technologies. One important clarification: this is not the same project as the older, unrelated JavaScript mini-engines or embedded scripting projects that circulate under the same name. The TinyJS discussed here is a newly introduced 2026 project by developer Tarwin Stroh-Spijer, found at tinyjs.app and in the GitHub repository github.com/tarwin/tinyjsapp.
The core idea is simple to state but technically demanding to execute: why should every desktop app have to ship its own Chromium when the operating system already provides a capable webview? That is exactly the question this Electron alternative answers, saving the bulk of the disk space that classic Electron applications require.
The technical architecture in detail
TinyJS is built on a two-process model that cleanly separates logic from presentation. That separation is the core of what distinguishes TinyJS from other frameworks.
The backend process: txiki.js as the foundation
The backbone of TinyJS is txiki.js, an ultra-compact JavaScript runtime created by Saúl Ibarra Corretgé. It is built on a combination of QuickJS (a small but complete JavaScript engine) and libuv (the event-loop library that also powers Node.js). At around 5.6 MB, txiki.js itself is already a lightweight.
This backend process gets full system access, including:
- File system operations
- Network sockets
- Process management
- FFI (Foreign Function Interface) for access to native libraries
- SQLite as a built-in database
- Modern web APIs such as fetch and WebSocket
That gives developers practically every tool they would expect from a full Node.js environment, just at a fraction of the size.
The frontend: a native system webview instead of Chromium
While the backend handles the logic, the frontend’s only job is rendering. For this, TinyJS relies on the webview that is already installed on the respective operating system:
- macOS: WebKit (Safari’s engine)
- Windows: WebView2, which is Chromium-based
- Linux: WebKitGTK
This approach is not new — Tauri uses it too. But TinyJS takes a notable approach of its own when it comes to how the two processes communicate.
Communication without an open port
Many web-based desktop frameworks let the backend and frontend talk over HTTP, which in practice means a small web server runs in the background, often with a locally open port. That is a potential security risk and can occasionally cause conflicts with firewalls or other applications.
TinyJS deliberately avoids that. Instead, the connection between the backend process and the webview window runs over:
- a private Unix socket on macOS and Linux
- a named pipe on Windows
Both mechanisms live in a temporary directory with 0700 permissions, readable and writable only by the owning user. There is no open network port and no classic web server that could be reached from the outside. This design choice noticeably reduces the attack surface and is one of the technical aspects that makes TinyJS an interesting Electron alternative, particularly for security-conscious development teams.
“You shouldn’t have to ship a whole Chromium just to show an HTML window” is roughly how the core philosophy behind TinyJS can be summarized, as described in The Register’s report.
TinyJS vs. Electron: a direct size comparison
Arguably the most compelling reason to look at TinyJS is simply the file size of finished applications. According to figures published on tinyjs.app, the picture looks like this:
| Framework | Approximate app size | Technical approach |
|---|---|---|
| Electron | at least 150 MB | Bundles Node.js plus a full Chromium |
| Tauri | approx. 10 MB | Rust backend, system webview |
| TinyJS | approx. 6 MB | txiki.js backend, system webview |
| Neutralino | approx. 3 MB | Lightweight backend, system webview |
These figures come directly from the project’s own website and show that TinyJS sits between Tauri and Neutralino, while staying miles below Electron. Anyone planning a new desktop app today, with size and resource usage as a deciding factor, can hardly ignore this comparison.
Platform status: where does TinyJS stand today?
Not all supported platforms are equally mature. The current state can be summarized as follows:
macOS is considered stable. Apps ship signed and notarized, which means macOS Gatekeeper shows no warnings and the app installs without extra hoops for users.
Windows (versions 10 and 11) is listed as beta. The only prerequisite is the WebView2 runtime, which comes preinstalled on Windows 11. Windows 10 users may need to install the runtime separately.
Linux is also in beta, but already supports both x86_64 and arm64 architectures. The prerequisite is the libwebkit2gtk-4.1-0 package, which can be installed via the package manager on most common distributions.
For production projects, that means macOS deployments can already be considered reliable today, while Windows and Linux builds should still be expected to have occasional rough edges.
Frontend development: familiar tools, a new runtime
A key advantage of this Electron alternative is that the actual frontend workflow barely changes. Developers write normal HTML, CSS, and JavaScript, including support for modern graphics APIs like WebGPU, which also makes TinyJS interesting for compute-heavy visual applications.
For a quick start, ready-made Vite templates are available for the following frameworks:
- React
- Vue
- Svelte
- Solid
- Preact
- Lit
- Alpine
Anyone already working with one of these frameworks can carry over their existing knowledge directly, without giving up their familiar toolchain.
Installation: getting started with TinyJS
Getting started with TinyJS is deliberately kept simple and follows installation patterns familiar from other developer tools.
For macOS and Linux, installation happens via a curl-based script run directly in the terminal. For Windows, a corresponding PowerShell script is available. Anyone who prefers to build from source will find a setup.sh script in the repository that automates the entire build process.
These installation paths are deliberately kept simple, so developers can go from an empty terminal to a working development environment within minutes — an aspect that stands out positively compared to the more complex setup processes of other frameworks.
TinyJS compared to Electron, Tauri, and Neutralino
Whether TinyJS is a good fit as an Electron alternative cannot be answered in blanket terms — it depends on the use case.
Compared to Electron, the clear advantage of TinyJS is file size and lower resource usage, since no additional Chromium runs in the background. Electron, in turn, offers maximum rendering-engine consistency across all platforms, since the same Chromium is used everywhere — something TinyJS cannot offer with its three different native webviews.
Compared to Tauri, which also relies on native webviews, TinyJS differs mainly on the backend: instead of using Rust, TinyJS stays entirely within the JavaScript ecosystem and uses txiki.js as a runtime that lowers the barrier to entry for developers without Rust experience.
Compared to Neutralino, which is even more compact at around 3 MB, TinyJS offers a more extensive backend feature set according to available information, for example through native SQLite support and FFI access.
Who is TinyJS a good fit for?
TinyJS is aimed primarily at developers with the following priorities:
- Small download and installation sizes for end users
- A full JavaScript workflow without switching to another programming language
- A security-conscious architecture with no open local ports
- Access to native system functions like the file system, processes, and databases
TinyJS is currently less suited for teams that need production-ready stability on all three platforms from day one, since Windows and Linux remain in beta.
Anyone generally interested in current JavaScript runtime developments can find further context on where the JS ecosystem is heading in our article on the Node.js 27 release cycle.
Conclusion and next steps
TinyJS shows that the path to smaller, leaner desktop applications doesn’t necessarily have to run through a new programming language. With txiki.js as a compact backend and the respective system webviews as the frontend, the project manages to hit app sizes of around 6 MB — a figure that undercuts Electron applications by a factor of twenty or more, without giving up the familiar JavaScript workflow.
The thoughtful choice of communicating via Unix sockets and named pipes instead of open HTTP ports is an additional argument for security-conscious development teams. At the same time, it’s worth keeping in mind that only the macOS version is currently considered stable, while Windows and Linux still need to mature.
Developers considering this Electron alternative for their next project should start by reviewing the GitHub repository at github.com/tarwin/tinyjsapp as well as the official project website tinyjs.app, test the installation scripts for their own platform, and set up a small example project using one of the available Vite templates. Given the early stage of development, it makes sense to focus production use on macOS for now while evaluating Windows and Linux builds in parallel, at their own pace, before relying on them in critical projects.
