Updated 10 Nov 2026: Nov 6–7 tinyjs 0.71.1 repairs broken Windows 0.71.0 packaged launches requiring manual redistribution; 0.72.0 adds restricted localhost player embedding.

Key details

  1. tinyjs 0.63.0 (October 21, 2026) blocks remote wrapped pages from opening local files or programs through shell.open; only http(s) and mailto destinations remain available to them.
  2. 0.63.0 also fixes auto-update accepting absent/mismatched builds and accidental reinstall/downgrade for unsigned update paths.
  3. 0.61.0 (October 20) adds opt-in Ed25519-signed update manifests, not enabled unless the app pins one or more public keys.
  4. tinyjs 0.48.0 on October 5, 2026 limits remote-origin tiny.win.printToPDF output after an arbitrary user-writable file overwrite risk.
  5. The preceding 0.47.1 release on October 4 fixes malformed messages bypassing the api capability gate; wrapper deployments should move beyond that release to 0.48.0 or newer.
  6. The project says apps that wrap a site or use api.origins should update.
  7. 0.47.0 closed a CORS-open proxy path that could expose arbitrary sites or local-network URLs and stopped sensitive clipboard/keychain values appearing in debug traces.
  8. 0.46.0 fixed privileged file-window behavior, cross-user Windows pipes and Linux iframe origin confusion.
  9. 0.42.3 fixed launcher command injection that could reach shell execution through AppleScript on macOS.
  10. tinyjs uses native system webviews and describes typical shipped app size as about 6MB; Windows and Linux are beta.
  11. tinyjs 0.71.0 packaged Windows apps can fail silently when launched by double-click due to inherited stdio handling in txiki.js 26.11.0; tinyjs dev may not reveal it.
  12. tinyjs 0.71.1 (Nov 6) repairs the launcher by ignoring stdin; affected distributed Windows builds need a new installer because they cannot auto-update.
  13. tinyjs 0.72.0 (Nov 7) adds allowlisted HTTPS player embedding via tiny.embedURL/app.embedURL through a localhost framing page, without lifting earlier shell.open gates.

What builders should take away

  1. Upgrade remote-site wrappers to at least tinyjs 0.63.0 and test external links, local helpers and packaged application-owned pages against the tighter shell.open origin rules.
  2. Pin Ed25519 public keys in update.publicKey and protect signing private keys outside release hosting; include a recovery/rotation key.
  3. Verify updates install only compatible OS/CPU builds and that no stale version is reinstated when there is no new update.
  4. If you ship tinyjs wrappers or configure api.origins, update to at least 0.48.0 and test PDF export paths and user save-dialog behaviour.
  5. Audit webview-to-native bridges as security boundaries: malformed RPC, iframe origin attribution and navigation policies deserve adversarial testing.
  6. Do not assume localhost or local IPC is automatically private on multi-user machines; bind identity and authenticate peers explicitly.
  7. Redact secrets in debug tooling because diagnostic paths often bypass the assumptions applied to production UI.
  8. For young runtimes, read several adjacent changelog releases rather than only the latest patch; security fixes can be distributed across a rapid hardening sequence.
  9. Audit file-writing APIs exposed to remote web content for arbitrary destination paths, not only origin permissions.
  10. Rebuild and manually redistribute any Windows desktop app packaged with tinyjs 0.71.0 using 0.71.1 or newer; advise affected users that the broken app cannot repair itself through auto-update.
  11. Add packaged-app Explorer double-click smoke tests without inherited stdio in addition to tinyjs dev tests; inspect custom tjs.spawn stdio handling.
  12. For embedded video, review embedHosts and embed.url scopes rather than granting unrestricted local shell access to wrapped sites.

What changed

tinyjs's security-hardening cycle continued after its October 5 0.48.0 printToPDF file-write fix. In 0.63.0 on October 21, the framework restricted shell.open on pages not shipped within the app to http(s) and mailto destinations; previously remote pages wrapped with the wrapper preset could pass local paths, file:// URLs or native OS schemes to shell.open, potentially launching a program they had just downloaded. In the same release, auto-update now refuses to install when no newer version exists for the running OS/CPU, preventing unrelated platform downloads or accidental reinstalls and downgrades. Version 0.61.0 on October 20 introduced opt-in Ed25519-signed update manifests, guarding against replacement of the remote update manifest or hosted payload when a signing key is pinned. Without a configured update public key, apps retain the prior unsigned update trust model. The previous 0.48.0 fixes to PDF output paths and preceding frame/proxy capability escapes remain relevant. NOVEMBER 6–7 FOLLOW-UP: tinyjs 0.71.0 upgraded to txiki.js 26.11.0; on Windows a packaged GUI app started by double-click from Explorer has no inherited standard streams. The newer tjs.spawn raised UNKNOWN when all three stdio handles were inherited, so the tinyjs launcher exited silently before opening any window. This did not reproduce in tinyjs dev, where stdio exists. On November 6, tinyjs 0.71.1 fixed this by setting launcher stdin to ignore. Every Windows app built using 0.71.0 is affected by the maintainer's account and cannot update itself because it cannot start; operators must rebuild with at least 0.71.1 and redistribute installers/app bundles manually. On November 7, tinyjs 0.72.0 added tiny.embedURL()/app.embedURL(), a localhost-framed way to embed approved HTTPS players (YouTube/Vimeo), with optional configured hosts and api embed.url permission. That new feature is separate from the Windows regression and the previously covered wrapper shell.open restrictions.

Why it matters

A small desktop wrapper that renders remote pages has two security boundaries: whether web content can invoke the user's operating system, and whether update infrastructure can replace the installed application. tinyjs shipped concrete fixes for both. Developers using tinyjs wrap or granting shell.open to third-party pages should upgrade past 0.63.0 and test their expected link-handling behaviour; privileged app-owned pages continue to have wider shell access. Signed updates are a separate opt-in control: upgrading alone does not activate manifest signing. Developers should pin the Ed25519 public key, keep the signing key outside the project and preserve a recovery key. These fixes are confirmed upstream, not evidence that every wrapper was attacked in the wild. The November 6 regression is urgent for Windows users deploying tinyjs desktop apps: smoke tests run through tinyjs dev will not catch packaged Explorer-launch failures, and a broken build cannot use its own auto-updater to repair itself. Teams should rebuild with the fixed runtime, distribute a new package out-of-band and add an end-to-end packaged Windows launch test without standard handles. The new embedURL loopback bridge is designed for selected approved HTTPS embed hosts; it does not imply that a wrapped untrusted site now receives unrestricted local shell/file privileges.

October 21: remote wrapped sites can no longer launch local programs

In tinyjs 0.63.0, shell.open on any remote page not shipped with the app is limited to HTTP, HTTPS and mailto. Before the fix, the wrapper preset exposed shell.open and handed arbitrary target strings to the native operating-system opener, including local executables or file:// URLs. A remote site could download a program and try to open it. App-owned pages retain their local/open-scheme privileges. Check that embedded remote sites still open legitimate external links after upgrading.

App updates can now be signed — but this is opt-in

Version 0.61.0 introduced Ed25519-signed update manifests with update.publicKey pinned in the app configuration. The signing private key stays outside the distributed project. Manifests can expire, and multiple public keys permit rotation. Without the configured public key, tinyjs's update trust remains based on the hosting endpoint, so supply-chain hardening requires developer configuration and key management.

Auto-update checks the right platform and version

Before 0.63.0, unsigned auto-update install could use a manifest's top-level download even when the release lacked a matching build for the current OS/CPU. On some configurations this could install the wrong platform artifact or reinstall/downgrade unexpectedly. The fix requires a successful per-platform new-version check before install; signed updates already applied that guard.

October 5 follow-up: wrapped pages could overwrite arbitrary files via PDF export

Version 0.48.0 fixes tiny.win.printToPDF(path) in the wrapper preset. The project's changelog says a wrapped remote-origin site could previously choose any user-writable output path, so a page could overwrite files by saving PDF bytes there. Now external origins can write directly only to Downloads, the application's data directory or a temporary directory. Other destinations open a user-controlled save dialog, and cancellation rejects the operation. PDF output from the app's own pages and backend app.printToPDF is unchanged. The change affects apps that wrap hosted sites and use the PDF API, and may require UX testing for exports to custom folders.

The latest bug bypassed the API gate itself

In 0.47.1, tinyjs changed all three platform launchers so malformed page messages are dropped before reaching the backend. The project says a restricted wrapped page or iframe could previously craft a message that bypassed the api gate, ran with the application’s permissions or invoked the application’s own event handlers. For a runtime built around controlled page-to-native RPC, that is a material boundary failure.

The audit found more than one route across the boundary

Version 0.47.0 restricted tiny.proxyURL after the project found that its CORS-open media proxy could fetch arbitrary HTTP(S) and local-network URLs for any page able to reach it. The same release routes external URL schemes through an explicit navigation policy, changes the updater so the tinyjs website no longer supplies executable installer code on every update, and redacts clipboard and keychain values from debug traces.

Local-machine isolation also needed work

Version 0.46.0 fixed a window-opening path that could turn a hostile page into a privileged local file window. On Windows it made single-instance and private app/window pipes user-specific and authenticated so another local account could not intercept OAuth callbacks, file paths or application traffic. On Linux it tightened iframe message handling so a cross-origin frame could not inherit the trusted top page’s API origin.

A page-controlled newline could become a shell command on macOS

Version 0.42.3 fixed a launcher command-injection issue in window IDs. Newlines could split the runtime’s launcher protocol and make the second line execute as a command. The project says the injection worked across platforms and that on macOS the reachable command set included AppleScript, allowing shell-command execution as the current user.

The project is small by design and still maturing

tinyjs uses the platform webview rather than bundling Chromium and says shipped apps are around 6MB. macOS is described as stable while Windows and Linux remain beta. The same minimal architecture that makes the runtime attractive also concentrates trust in a small launcher/RPC surface, making the recent audit and update cadence especially relevant to early adopters.

Nov 6: Windows 0.71.0 packaged applications fail silently on launch

The primary tinyjs changelog documents that every Windows app built with 0.71.0 fails when started by double-click from Explorer because a txiki.js 26.11.0 tjs.spawn change rejects inherited stdin/stdout/stderr without valid handles. The launcher's backend exits before the window appears. Version 0.71.1 changes the launcher's stdin to ignore. The CLI development path masks the problem because terminal stdio is present. Already distributed broken apps cannot invoke their own updater; the maintainer specifically instructs teams to rebuild and reship the Windows app, with manual redownload for users. Custom backend process spawns using all three inherited streams may need at least one stream set to ignore or pipe.

Nov 7: local HTTPS player embedding without reopening wrapper shell permissions

tinyjs 0.72.0 adds tiny.embedURL() and app.embedURL() to embed selected HTTPS players such as YouTube and Vimeo when direct file:// iframe loading lacks the Referer required by those providers. It serves a small framing page from a localhost listener on a per-launch ephemeral port, and limits service to URLs the app requests; additional hosts require embedHosts configuration, and restricted app APIs require embed.url to be enabled. The feature is distinct from—and should not be conflated with—the 0.63.0 shell.open restriction for untrusted remote wrapper pages.

What to watch next

  • Whether tinyjs's Windows packaged-launch fix receives independent regression tests for double-click launch and auto-update recovery.
  • Later releases tightening remote-origin capabilities, signed-update defaults, app permissions and migration implications.
  • Whether the maintainer publishes CVEs or independent audit findings for shell.open and prior capability escapes.
  • Whether subsequent tinyjs security releases further restrict wrapper file access or require compatibility changes.
  • Whether tinyjs publishes formal security advisories or CVE identifiers for the reported issues.
  • Further findings from the external audit credited to @slabbdev.
  • Whether Windows and Linux move out of beta after the current cross-platform security hardening.
  • Any compatibility changes required by tighter api.origins, proxy or navigation policies.

Still unclear

  • No verified exploitation campaign targeting these specific tinyjs wrapper paths was established.
  • Signed-update adoption among apps is unknown, and signing remains opt-in.
  • The arbitrary-file-write scope is described in the project's October 5 changelog; no separate CVE or independent exploitation report was located.
  • The impact descriptions come from the tinyjs project changelog and linked reporter issues; there is not yet a separate public security advisory for every fix.
  • The project does not publish install-base data, so the number of affected applications is unknown.
  • Some vulnerabilities require specific configurations such as wrapped sites, permissive API exposure or local multi-user conditions.
  • Windows and Linux are explicitly beta, so their security and compatibility surface is still evolving.
  • Maintainer release notes establish the Windows launch defect and repair, but do not quantify the installed user base affected or establish other operating systems sharing the failure.

Sources

Direct reading behind this dossier.

5 sources
tinyjs changelog
tinyjs official changelog

Primary changelog through 0.48.0 (October 5), including PDF arbitrary-file-write fix and earlier security-hardening sequence.

Security audit issue #30
tinyjs GitHub issue report

Reporter/audit context linked by the project changelog for the October security fixes.

Discussion

Discussion is reader-contributed. Comments are not part of the BTN dossier or its editorial evidence.

0 visible comments

Join the discussion

Keep comments useful and relevant. Reader contributions may be moderated and are not BTN editorial evidence.

Sign in to comment