tarwin/tinyjsapp

tinyjs

Install

curl -fsSL https://tinyjs.app/install | sh

git clone https://github.com/tarwin/tinyjsapp && cd tinyjsapp
./setup.sh    # downloads the txiki.js runtime, compiles the launcher
ln -s "$(pwd)/tinyjs" /usr/local/bin/tinyjs

irm https://tinyjs.app/install.ps1 | iex

git clone https://github.com/tarwin/tinyjsapp; cd tinyjsapp
powershell -ExecutionPolicy Bypass -File setup.ps1
# adds the checkout to your user PATH (-SkipPath to opt out); after that,
# `tinyjs dev` auto-rebuilds the launcher whenever the native sources change

# Debian/Ubuntu
sudo apt install gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav
# openSUSE
sudo zypper install gstreamer-plugins-bad gstreamer-plugins-ugly gstreamer-plugins-libav

if (tiny.system.isLinux()) {
  audio.volume = volume;          // straight to the speakers, no graph
  await tiny.audioTap.start({ scope: 'app' });   // PCM for your visualiser
} else {
  const src = ctx.createMediaElementSource(audio);
  src.connect(gain); gain.connect(ctx.destination);
}

Create and run an app

tinyjs new myapp
cd myapp
tinyjs dev

myapp/
  tinyjs.json            # { name, title, size, id, version, icon?, signIdentity?,
                         #   urlScheme? (string or array), fileExtensions?, chrome?, update?, notarize?,
                         #   permissions? ({ microphone, camera, speechRecognition: "why" }),
                         #   audioTap? ("app" | "system"), audioTapReason? (macOS prompt text),
                         #   contextMenu? (false suppresses WebKit's default right-click menu),
                         #   debug? (true = F12 opens devtools (⌥⌘I also works on macOS),
                         #   "open" = every window auto-opens them; default off — `tinyjs dev` always has F12),
                         #   browserAccelerators? (true re-enables the engine's own keys —
                         #   Ctrl+F find, Ctrl+R reload…; default suppressed, Windows only),
                         #   activation? ("regular" default | "accessory" = menu-bar agent: no Dock, starts hidden),
                         #   mainWindow? (false = no main window/WebView at all — tray agents),
                         #   macos?/windows?/linux? (merged on top for that OS),
                         #   minTinyjsVersion? (refuse to run on an older tinyjs) }
  assets/                 # files the OS reads, by name — see "App assets"
    icon.png              #   1024×1024 app icon (template ships a default)
    Credits.html          #   optional: About panel credits (or .rtf / .rtfd)
    My App Help/          #   optional: macOS help book ("macos": { "helpBook" })
  resources/              # optional: data your code reads — see "Bundled data resources"
  executables/            # optional: programs your code spawns — see "Bundled executables"
  src/backend/main.js     # backend: export const api = {...}; export function init(app) {}
  src/frontend/           # index.html + any local js/css/images
  src/shared/             # optional: code both sides import — see below

// src/shared/settings.js
export const MY_CONSTANT = 42;

// src/backend/main.js and src/frontend/app.js alike
import { MY_CONSTANT } from '../shared/settings.js';

{
  "name": "myapp",
  "chrome": { "frame": false },

  "macos":   { "signIdentity": "Developer ID Application: …",
               "chrome": { "vibrancy": "hud" } },
  "windows": { "icon": "icon.ico" },
  "linux":   { "icon": "icon-512.png" }
}

Writing the app

export const api = {
  hello: async ({ name }) => `hi ${name}`,
};
export function init(app) {          // window is up
  setInterval(() => app.push('tick', Date.now()), 1000);
  // app also has: setTitle(t), setSize(w, h), menu.set(menus), eval(js),
  // reload(), quit(), notify(title, body, opts), hide()/show()/center()/
  // minimize()/fullscreen(), setPosition(x, y), setAlwaysOnTop(v),
  // setResizable(v), setHideOnClose(v), presence(mode), print(),
  // restore(), setFullscreen(v), win.getState(), win.open(id, opts), setChrome(opts),
  // startDrag(), zoom(), tray.set/remove,
  // menu.update(id, patch), menu.get(id), info(), paths(), store.get/set/delete/all,
  // hotkey.register(id, combo)/unregister(id), menu.setContext(items),
  // update.check()/update.install(),
  // clipboard.read()/write(data)/changeCount()/watch(ms)/unwatch(),
  // keystroke(combo), paste(), permissions.check(name)/request(name),
  // mousePosition(), screens(), show({ activate: false }),
  // shell.open(target)/reveal(path)/trash(path),
  // launchAtLogin.get()/set(v), badge(text), attention(opts),
  // power.preventSleep(reason, opts)/allowSleep(), frontmostApp(),
  // beep(), playSound(target), window(id).share(opts),
  // system.* (os/info/capabilities/requirements/battery/idleTime/…),
  // theme.get(), captureScreen(screenId),
  // pickColor(), ocr(path), thumbnail(path, size),
  // secrets.get/set/delete, authenticate(reason),
  // nowPlaying.set/clear, say(text, opts), voices(), stopSpeaking(),
  // recorder.start({ path, screenId })/stop(),
  // selectedText(), otherWindows(), moveWindow(pid, rect),
  // window(id).setClickThrough/setLevel/setAllSpaces, tray.position(),
  // printToPDF(path), icon(png), presence(mode),
  // macos.applescript(source)/quickLook(paths),
  // battery(), wifi(),
  // spotlight(query)
}

export function onMenu(id, app) {}   // optional: handle menu clicks backend-side
export function onTray(id, app) {}   // optional: tray clicks (id null = bare icon)
export function onHotkey(id, app) {} // optional: global hotkey presses
export function onContextMenu(id, app) {}      // optional: context menu clicks
export function onSystem(kind, value, app) {}  // optional: 'theme'|'sleep'|'wake'

import { Database } from 'tjs:sqlite';
await tjs.makeDir(dataDir, { recursive: true });  // every tjs.* fs call is
// async — miss this await and the Database() below races the mkdir
const db = new Database(dataDir + '/notes.db');
db.exec('CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text)');
const st = db.prepare('INSERT INTO notes (text) VALUES (?)');
st.run('hello'); st.finalize();
db.prepare('SELECT * FROM notes').all();   // [{ id: 1, text: 'hello' }]

db.prepare('INSERT INTO notes (text) VALUES (?) RETURNING id').all('hi')[0].id;
// or: db.prepare('SELECT last_insert_rowid() AS id').all()[0].id

// backend
export const api = {
  notes: () => db.prepare('SELECT * FROM notes').all(),
  addNote: ({ text }) => { db.prepare('INSERT INTO notes (text) VALUES (?)').run(text); },
};
// frontend
const notes = await tiny.api.call('notes');
await tiny.api.call('addNote', { text: 'hi' });

const greeting = await tiny.api.call('hello', { name: 'world' });  // request/response
tiny.api.on('tick', (t) => ...);                                   // backend push
// on() is additive (addEventListener-style: N handlers, all fire) and returns
// an unsubscribe; there's also tiny.api.off('tick', fn). The tiny.*.on sugar
// (menu.on, tray.on, theme.on, …) returns the unsubscribe too — and since the
// sugar wraps your callback, that return value is the only way to unhook it:
const stop = tiny.api.on('tick', onTick);   stop();
tiny.api.off('tick', onTick);               // same thing, by reference

tiny.log('debug msg');  tiny.quit();
// tiny.log prints from the BACKEND, tagged [web] — so the page's lines and
// the backend's interleave in one terminal, in the order they happened.
// Objects arrive as objects; it resolves true once the backend has the line.
tiny.notify('Done', 'Your export finished');   // desktop notification
// packaged apps get REAL Notification Center banners (your app's icon,
// permission prompt on first use) when built with a signing identity —
// even "Apple Development" works. Ad-hoc/dev builds fall back to osascript.
tiny.notify('Ping', 'body', { id: 'x', subtitle: '…', sound: true });
tiny.app.onNotificationClick((id) => ...);  // backend: export onNotificationClick
await tiny.app.info();  // { version: <app>, tinyjs: <built with>, runtime: <txiki> }

// window control
// setSize/size are the PAGE's box (decorations excluded) — 1200x800 of
// document on every OS, whatever the title bar adds around it.
tiny.win.setTitle('My App');  tiny.win.setSize(1200, 800);
tiny.win.center();  tiny.win.setPosition(100, 80);      // top-left origin
tiny.win.minimize();  tiny.win.restore();
tiny.win.fullscreen();  tiny.win.setFullscreen(true);   // toggle / absolute
tiny.win.setAlwaysOnTop(true);  tiny.win.setResizable(false);
tiny.win.hide();  tiny.win.show();
// hide() hides the APP (NSApp hide) — macOS returns focus to the previously
// active app on its own, so a palette can hide() then app.paste() with no
// frontmost-pid bookkeeping. show() re-activates;
tiny.win.show({ activate: false });  // …or surface WITHOUT stealing focus
                                     // (overlay/HUD panels)
tiny.win.hide({ app: false });       // …or put away THIS WINDOW only, app
                                     // stays frontmost (a welcome/launcher
                                     // window stepping aside for documents)
tiny.win.setHideOnClose(true);  // close button hides instead of quitting

// global cursor position (same top-left coords as setPosition — handy for
// popping a palette at the mouse)
const { x, y, window, screen } = await tiny.app.mousePosition();
// window = relative to this window's content area, clientX/clientY units,
//          valid even while the cursor is OUTSIDE it: { x, y, inside }
// screen = the display the cursor is on: { x, y, width, height, scale }

// frameless / transparent / vibrancy windows (native resize + focus kept)
tiny.win.setChrome({ frame: false, windowControls: false, vibrancy: 'hud' });
// mark your own titlebar: <header data-tiny-drag>…</header> — drag moves the
// window, double-click zooms; interactive children are excluded automatically
// (or opt out with data-tiny-nodrag). Also in tinyjs.json as "chrome": {…}
// (packaged apps apply it before first paint — no titlebar flash).
tiny.win.startDrag();  tiny.win.zoom();   // manual equivalents

// Resizing a frameless window: only macOS keeps native edges throughout. An
// undecorated GTK window has none, and neither does a frameless SECONDARY
// window on Windows (WebView2's child HWND covers the whole rect, so the
// resize border is never hit-tested) — so on Linux, and for Windows
// satellites, the client adds invisible 5px grips around the edge
// automatically. Nothing to do per app. The Windows MAIN window is the
// exception: it keeps real left/right/bottom borders, trading the top edge.
tiny.win.startResize('se');   // 'n','ne','e','se','s','sw','w','nw' — for your own handle
// A fixed-size window (a Winamp-style deck) opts out of the grips:
//   <html data-tiny-noresize>   …or make it non-resizable:
tiny.win.setResizable(false);
// setResizable(false) means the USER can't drag the edges — your own
// setSize() still works, including shrinking to a titlebar for a shade view.
tiny.win.setMinSize(900, 640);   // a FLOOR rather than a lock (win.open takes
// the same as minSize: '900x640'). Same rule as above on macOS and Windows —
// it binds the user, not your setSize; GTK clamps both.
tiny.win.setZoom(2);   // native page zoom (0.25–5), rendered by the webview so
// it stays crisp. The page keeps laying out in CSS px and just has fewer of
// them — pair with setSize(w*2, h*2) for a real "double size" mode.

// square corners (drop macOS's rounded window corners). This makes the
// window BORDERLESS — square, no titlebar, no traffic lights — and is
// deliberately un-native: you lose the native titlebar drag (use
// data-tiny-drag) but keep resize edges, the shadow, and keyboard focus.
tiny.win.setChrome({ squareCorners: true });
// declare it in tinyjs.json "chrome": { "squareCorners": true } so it
// applies before first paint (no rounded→square flash on launch).

// acceptsFirstMouse: true delivers the click that focuses an unfocused window
// through to the page (macOS swallows it by default — "click once to focus,
// again to act"). Handy for palettes/toolbars and DOM drag regions.
tiny.win.setChrome({ acceptsFirstMouse: true });

// move the traffic lights (macOS): { x, y } from the window's top-left, for
// frameless windows whose custom titlebar is taller than the default corner
// assumes. One call — the launcher re-applies it across resizes and
// fullscreen round-trips. null restores the OS layout. Ignored on Windows
// and Linux. Also in tinyjs.json "chrome" so it applies before first paint.
tiny.win.setChrome({ windowControlsPos: { x: 12, y: 24 } });

// hide this window's menu bar (Windows/Linux draw one per window; macOS has
// one bar for the app, so it's ignored there). Also tinyjs.json
// "chrome": { "menu": false }, or win.open's chrome, to start without one.
tiny.win.setChrome({ menu: false });

// read the window back
const s = await tiny.win.getState();
// { x, y, width, height, outer: { width, height },
//   fullscreen, minimized, visible, focused,
//   alwaysOnTop, resizable, chrome: { frame, windowControls,
//   windowControlsPos, transparent, vibrancy, squareCorners,
//   acceptsFirstMouse },
//   screen: { width, height, scale } }
// width/height are the page's box — hand them straight back to setSize and
// nothing moves. outer is the footprint on screen, decorations in (the page
// can't work that out itself: window.outerWidth is 0 in a WKWebView).
// x/y are the window's top-left, the units setPosition takes.

// …or don't poll it: window-state transitions arrive as events, whatever
// the cause (green button, menu item, F11, your own setFullscreen call).
const off = tiny.win.onState(({ win, fullscreen, maximized, minimized, focused }) => {
  // same vocabulary as getState(); `win` because events are broadcast —
  // every page hears about every window and filters by id ('main' or a
  // win.open id). Wayland never reports `minimized` (compositor-private).
});
off();   // like every tiny on…, it returns its own unsubscribe

// files dragged onto the window arrive with REAL filesystem paths
tiny.win.onDrop((paths) => tiny.log(paths.join(', ')));
tiny.win.print();                      // native print panel for the page

// persistent settings (JSON in ~/Library/Application Support/<app id>/)
await tiny.store.set('recent', ['/tmp/a.txt']);   // true once on disk; false =
//   write failed: kept in memory (like localStorage) and written by the next
//   successful save, lost if the app quits first. Never rejects.
const recent = await tiny.store.get('recent');      // value | null
await tiny.store.delete('recent');  await tiny.store.all();

// fetch that runs in the BACKEND — no CORS, CSP, or mixed-content limits,
// so the page can hit any origin. Same shape as window.fetch, returns a
// real Response (res.json()/res.text()/res.headers/res.ok all work).
const r = await tiny.fetch('https://api.example.com/data', {
  method: 'POST', headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ q: 'hi' }),
});
const data = await r.json();
// { stream: true } gives a LIVE streaming body — the whole point for endless
// sources like internet radio (a buffered fetch would never resolve). The
// backend keeps the connection and the page pulls chunks on demand, with
// natural backpressure; res.body.getReader() is the endless tap.
const radio = await tiny.fetch('https://ice1.somafm.com/groovesalad-128-mp3', { stream: true });
const reader = radio.body.getReader();
for (;;) { const { value, done } = await reader.read(); if (done) break; /* feed decodeAudioData, MediaSource, … */ }
// reader.cancel() (or closing the window) tears the upstream connection down.
//
// Reachability: tiny.fetch (and plain fetch() in the backend) transparently
// hands two cases the bundled runtime can't do on its own to the system curl:
// root-path URLs like https://feeds.example.com/ (the runtime emits 'GET //',
// which strict CDNs 404) and TLS 1.2-only hosts (art19, anchor.fm — the
// runtime's TLS stack requires 1.3). Redirects are followed hop by hop so a
// tracker that bounces into either case still lands. curl is only consulted
// when the built-in path failed at the wire — a real HTTP error (404, 500)
// is returned as-is, never retried. curl ships with macOS, Linux, and
// Windows 10 1803+; without it those two cases fail as before. Details in
// TODO-txiki.md (the plan is to fix the runtime itself and drop the shim).

// tiny.proxyURL — get a cross-origin stream (internet radio) INTO Web Audio.
// A MediaElementSource on a cross-origin <audio> outputs silence by spec;
// proxyURL streams the remote through the native layer with permissive CORS,
// so the element is untainted and the full EQ/analyser graph gets real samples.
const audio = document.querySelector('audio');
audio.crossOrigin = 'anonymous';
audio.src = tiny.proxyURL('https://ice1.somafm.com/groovesalad-128-mp3');
const ctx = new AudioContext();
ctx.createMediaElementSource(audio).connect(ctx.createAnalyser()); // …→ EQ → destination
audio.play();
// The native layer does the HTTP (following redirects), http/https only.
// Only the app's own pages may use it: any other origin (a wrapped site, a
// third-party iframe) is refused unless its tinyjs.json "api".origins key
// allows "media.proxy".
// Live internet radio works too: a non-seekable stream that answers 200 with no
// Content-Length (icecast/shoutcast) is served to the element with a synthetic
// large length so CoreMedia plays it progressively and the analyser sees real
// samples. Tradeoff: audio.duration/currentTime are meaningless for such a live
// stream (huge fake timeline) — don't wire a seekbar to one.

// system-wide hotkeys (work while other apps are focused)
tiny.hotkey.register('boss', 'cmd+shift+k');
tiny.hotkey.on((id) => tiny.win.show());
tiny.hotkey.unregister('boss');

// tiny.audio.sampler — sampled sound effects (game/UI SFX): a bank of short
// decoded sounds (wav/mp3/flac) fired with per-voice vol/pan/rate, one mixed
// output, 32 voices with oldest-stealing. Works on Linux (native mix in the
// launcher — Web Audio crackles there) and macOS/Windows (Web Audio in the
// main window's page) with identical behavior; backend twin app.audio.sampler
// drives the same mixer. Not for music — that's <audio>.
const s = tiny.audio.sampler;
await s.load('coo', '/abs/path/coo.mp3');       // or an ArrayBuffer
const v = await s.play('coo', { vol: 0.8, pan: -0.3, rate: 1.06 });
v.set({ pan: 0.1 });                            // live, no restart
v.stop();                                       // short fade, no click
s.master(0.5); s.stopAll(); s.unload('coo');

// tiny.audioTap — read the app's rendered audio OUTPUT as PCM (VU meters,
// visualizers) — including audio that bypasses Web Audio (native HLS,
// CORS-tainted streams). Read-only; needs "audioTap": "app" in tinyjs.json
// ("system" for scope: 'system'; "audioTapReason" sets macOS's prompt text).
await tiny.audioTap.start({ scope: 'app', interval: 80 });
tiny.audioTap.on(({ pcm, sampleRate, channels, frames }) => {
  const bin = atob(pcm), n = bin.length >> 1;   // base64 -> interleaved LE Int16
  let peak = 0;
  for (let i = 0; i < n; i++) {
    const v = ((bin.charCodeAt(2*i) | (bin.charCodeAt(2*i+1) << 8)) << 16 >> 16) / 32768;
    if (Math.abs(v) > peak) peak = Math.abs(v);
  }
  meter.style.height = (peak * 100) + '%';       // channels/frames describe the layout
});
// tiny.audioTap.stop();  // (or the owning window closing) tears the tap down.
// Authorization is deferred to the first start() — declaring the
// manifest key does nothing until you call it — so you can lazy-arm the tap the
// first time a meter is shown. The FIRST start() prompts for "System Audio
// Recording" (even scope:'app' — WKWebView renders audio in a separate
// com.apple.WebKit.GPU helper, so the tap is a cross-process capture); the
// grant persists per app. scope:'system' also hears other apps (excludeSelf
// drops your own). NOTE: under `tinyjs dev` the audio "owner" is your terminal,
// not your app — the tap delivers real PCM only if that terminal holds the
// System Audio Recording grant, otherwise silent chunks; a built .app owns its
// own grant. Denial can't be reported synchronously — it surfaces as silence.

// custom right-click menu (native NSMenu; null restores WebKit's default)
tiny.menu.setContext([{ id: 'copy-path', label: 'Copy Path' }, { separator: true }, { id: 'del', label: 'Delete' }]);
tiny.menu.onContext((id) => ...);
// to hide WebKit's default menu entirely (Reload/Back/Inspect Element…) for an
// app-like feel, set "contextMenu": false in tinyjs.json. setContext still wins.

// system theme + power events
const { dark } = await tiny.theme.get();
tiny.theme.on((dark) => document.body.classList.toggle('dark', dark));
tiny.api.on('sleep', () => ...);  tiny.api.on('wake', () => ...);

// clipboard — native NSPasteboard in the launcher process (no pbpaste/
// osascript spawns, no scratch files, multi-file writes never lose the tail)
const clip = await tiny.clipboard.read();
// { kind: 'files'|'image'|'color'|'text'|'empty', changeCount, text, html,
//   paths, image, imageSize, color, concealed, sourceApp, sourceURL }
// image: png temp path, valid until the clipboard changes again (copy the
//   file to keep it); imageSize: { width, height } px
// concealed: password-manager marker (org.nspasteboard) — history apps skip
// sourceApp: { name, bundleId } frontmost when the change was noticed
//   (exact while watch() runs); sourceURL: Chromium copy's page url
tiny.clipboard.write({ text: 'hi' });                    // any combination of
tiny.clipboard.write({ paths: ['/tmp/a.png', '/tmp/b.png'] });  // text, html,
tiny.clipboard.write({ image: pngPathOrBase64, color: '#ff8800' }); // paths…
await tiny.clipboard.changeCount();          // cheap "did it change?" probe
tiny.clipboard.watch(500);                   // launcher-side change polling
tiny.clipboard.onChange(({ changeCount, self }) => ...);  // self = own write
tiny.clipboard.unwatch();                    // stops delivery, not the counter:
// the OS keeps counting, so one changeCount() after a gap (a wake, a window
// coming back) says whether re-reading is worth it — without reading contents
// backend: same api as app.clipboard.*; a createApp onClipboardChange
// handler auto-starts the watcher

// drag files OUT of the app — into Finder, Slack, anywhere (real files).
// Must be called from a mousedown handler while the button is held:
row.addEventListener('mousedown', () =>
  tiny.win.startDrag({ files: ['/tmp/report.pdf'], image: undefined }));

// native keystrokes — a CGEvent posted by the launcher. ONE permission
// (Accessibility) whose prompt names your app; no osascript, no spawn.
await tiny.app.keystroke('cmd+v');           // -> { ok, trusted }
await tiny.app.paste();                      // = keystroke('cmd+v'); call
                                             // win.hide() first so the paste
                                             // lands in the frontmost app

// permissions — check before use, build onboarding instead of failing
await tiny.app.permissions.check('accessibility');
// 'granted' | 'denied' | 'undetermined' | 'unsupported'
await tiny.app.permissions.request('accessibility');  // prompt/open Settings
// names: 'accessibility', 'screen', 'notifications' (packaged apps),
//        'microphone', 'camera' (TCC layer under getUserMedia),
//        'automation' (System Events) or 'automation:<bundle-id>'
// 'screen' never reads 'undetermined' — macOS only exposes a yes/no
// preflight for screen recording ('denied' until granted in Settings).
// mic/camera: getUserMedia() just works on the app's own pages — the
// launcher grants WebKit's per-origin prompt so users only see the system
// dialog naming your app. Any other origin (a wrapped site, a redirect, a
// third-party iframe) gets the engine's own permission prompt (macOS,
// Windows) or a denial (Linux) unless an "api.origins" key allows
// "media.microphone" / "media.camera" for it.
// Speech-to-text isn't a tiny.* call at all — the page's own
// webkitSpeechRecognition works (WebKit and WebView2 both have it), but a
// packaged app must declare BOTH "microphone" and "speechRecognition" usage
// strings or the OS refuses the service with `service-not-allowed` and no
// prompt. Pair it with app.say() and macos.ai for a hands-free loop.
// Packaged apps declare "permissions": {"microphone": "why", ...} in
// tinyjs.json → Info.plist usage strings + hardened-runtime entitlements.
// Dev-mode note: TCC grants attach to the SHARED launcher binary
// (~/.tinyjs), not your app — all dev apps share them, and a launcher
// update re-prompts. Packaged apps carry their own identity and grants.

// shell — the NSWorkspace verbs apps otherwise spawn `open` for
await tiny.app.shell.open('https://tinyjs.app');   // default browser
await tiny.app.shell.open('/path/to/report.pdf');  // default app for the file
await tiny.app.shell.reveal('/path/to/file');      // show in Finder
await tiny.app.shell.trash('/path/to/file');       // recoverable (prefer over
                                                   // deleting user files)
// each resolves true, or rejects with the reason ('no such file',
// 'no application registered for URL', …)

// every display, same top-left coords as win.setPosition
const screens = await tiny.app.screens();
// [{ id, name, x, y, width, height, visible: { x, y, width, height },
//    scale, primary }] — visible excludes the menu bar and Dock; primary
// is the menu-bar screen (the coordinate origin)

// standard per-app directories — prefer over hardcoding ~/Library paths
const paths = await tiny.app.paths();
// { home, data, cache, logs, temp, downloads, desktop, documents }
// data/cache/logs are per app id; create them on first write
// (backend: the same — await app.paths())

// launch at login (built apps on all three OSes; dev mode -> 'unsupported')
await tiny.app.launchAtLogin.get();       // 'enabled' | 'disabled' |
await tiny.app.launchAtLogin.set(true);   //   'requires-approval' | 'unsupported'
// 'requires-approval': macOS wants the user to allow it in
// System Settings > General > Login Items

// decorate the OS's app surface: Dock (macOS), taskbar (Windows),
// launcher (Linux) — verbs named for intent, not for furniture
tiny.app.badge('3');  tiny.app.badge('');  // '' clears
tiny.app.attention();                      // until the app is activated
tiny.app.attention({ critical: true });    // until the user acts

// keep the system awake — replaces spawning `caffeinate` (the assertion
// dies with the app, so a crash never wedges sleep); the reason shows in
// `pmset -g assertions`
await tiny.app.power.preventSleep('Exporting video');
await tiny.app.power.preventSleep('Playing', { display: true }); // screen too
await tiny.app.power.allowSleep();

// the active app right now — who focus returns to after win.hide()
const front = await tiny.app.frontmostApp();  // { name, bundleId, pid } | null

// sounds — system beep, a system sound by name, or an audio file
await tiny.app.beep();
await tiny.app.playSound('Ping');            // -> false if it didn't load
await tiny.app.playSound('/path/to/done.aiff');

// native share sheet — anchor it at the click
btn.addEventListener('click', (e) =>
  tiny.win.share({ url: 'https://tinyjs.app', text: 'Look at this',
                   paths: ['/tmp/report.pdf'], x: e.clientX, y: e.clientY }));

// seconds since the user's last input (pause polling when they're away)
const idle = await tiny.system.idleTime();

// files named on the command line reach onOpenFiles — cold start on all
// three platforms, and forwarded to the running copy over the instance pipe
// on win/linux. `tinyjs build --cli [name]` writes dist/bin/<name>, a shim
// that's just `exec <backend> "$@"`.
export function onOpenFiles(paths, app) { /* argv, LaunchServices, drag-drop */ }

// become the default opener for an extension — ask because the USER asked
await tiny.app.setAsDefaultHandler('md');   // 'ok' | 'unsupported' | 'failed'

// the user's languages + time zone, read from the OS — NOT from LANG, which
// Windows doesn't have and which elsewhere describes the parent process
const { language, languages, system, region, timeZone } = await tiny.system.locale();
// `languages` is filtered to the localizations the app bundle declares;
// `system` is the raw preference. They differ for an English-only app on a
// French Mac — render with the first, offer a translation based on the second.
//
// A PAGE rarely needs this: navigator.language / navigator.languages / all of
// Intl / the 'languagechange' event work in the webview. The BACKEND is the
// gap — txiki has no Intl at all, so format in the page and branch on
// language in the backend.

// Quick Look — the Finder-spacebar preview panel (no qlmanage spawn);
// an array pages with the arrow keys, no args closes it
tiny.macos.quickLook('/path/to/photo.heic');
tiny.macos.quickLook([a, b, c]);   tiny.macos.quickLook();

// screenshot a display (id from screens(); default primary) — png in the
// temp dir, you own the file. Needs the 'screen' permission;
// rejects with the reason otherwise.
const { path, width, height } = await tiny.app.captureScreen();

// the system eyedropper — pick any pixel on screen, in any app; needs NO
// screen-recording permission. '#rrggbb', or null if the user cancels.
const color = await tiny.app.pickColor();

// on-device OCR (Vision) — screenshot-to-text is captureScreen + this
const { text, blocks } = await tiny.macos.ocr('/path/scan.png');
// blocks: [{ text, confidence, box }] — box normalized 0..1, top-left

// a thumbnail png for ANY path — file browsers stop caring about formats.
// A content preview where Quick Look has a renderer (PSD, video, 3D models,
// source files); the document / app / folder ICON where it doesn't, so on
// macOS this never fails on file type alone. WINDOWS behaves the same way
// via IShellItemImageFactory — images preview, and folders, .exe and plain
// text all come back as their shell icon (measured 2026-07-28). LINUX is the
// narrow one: images only, everything else rejects 'no thumbnail' (measured
// 2026-07-28) — so feature-detect per file, not per platform.
// A path that doesn't exist rejects everywhere.
// SIZE: macOS and Linux treat `size` as points and render @2x (ask 64, get
// 128); Windows treats it as pixels and returns exactly what you asked for.
// Read width/height off the result rather than assuming either.
const thumb = await tiny.app.thumbnail('/path/file.psd', 256);

// Keychain secrets (the keytar/safeStorage role) — tokens go here,
// never in tiny.store; values survive reinstalls
await tiny.app.secrets.set('api-token', 'abc123');
const tok = await tiny.app.secrets.get('api-token');   // string | null
await tiny.app.secrets.delete('api-token');
// set replaces rather than duplicating; delete of a key that was never
// there still resolves true. On macOS the keychain ACL names the binary
// that wrote the value, so a secret saved under `tinyjs dev` makes the
// BUILT app prompt once when it first reads it (a dev-only annoyance).

// Touch ID (or the account-password sheet) — "the user proved it's them".
// false covers cancel AND unavailable, and Linux has no owner check at
// all, so it answers false there — a gate on this fails closed.
if (await tiny.app.authenticate('unlock the vault')) { /* … */ }

// AppleScript in-process — control Music, Spotify, Finder, any scriptable
// app; no osascript spawn, same 'automation' permission as keystrokes
await tiny.macos.applescript('tell application "Music" to playpause');
const sum = await tiny.macos.applescript('return 2 + 3'); // '5'

// Now Playing — your media app shows in Control Center / the lock screen
// and the hardware media keys (F7/F8/F9, AirPods) route to you
tiny.app.nowPlaying.set({ title: 'Song', artist: 'Band', album: 'LP',
                          duration: 240, elapsed: 12, playing: true });
tiny.app.onMediaKey(({ command, time }) => {  // play|pause|toggle|next|
  if (command === 'toggle') togglePlayback();  // previous|seek (time = secs)
});
tiny.app.nowPlaying.clear();

// text-to-speech with the system voices; say() resolves when playback ends
const voices = await tiny.app.voices();  // [{ id, name, lang, quality }]
await tiny.app.say('Export finished', { voice: voices[0].id, rate: 0.5 });
tiny.app.stopSpeaking();

// notifications with action buttons + a reply field (packaged apps)
tiny.notify('New message', 'from Alex', { actions: [
  { id: 'reply', title: 'Reply', reply: true, placeholder: 'Message…' },
  { id: 'mute', title: 'Mute' },
  { id: 'del', title: 'Delete', destructive: true },
]});
tiny.app.onNotificationAction(({ id, action, reply }) => {
  if (action === 'reply') sendReply(reply);   // reply = the typed text
});

// record a display to an .mp4 (SCStream → H.264; video only for now).
// Needs the 'screen' permission; one recording at a time.
await tiny.macos.recorder.start({ path: '/tmp/demo.mp4' });   // screenId optional
// … later …
const { path, duration } = await tiny.macos.recorder.stop();  // finalized file

// window superpowers — overlays, HUDs, desktop pets, palettes that follow
// you across Spaces. clickThrough lets mouse events pass through the window.
tiny.win.setClickThrough(true);              // draw-on-screen / HUD overlays
tiny.win.setLevel('overlay');                // 'normal'|'floating'|'overlay'
                                             //  |'desktop' (behind windows)
tiny.win.setAllSpaces(true);                 // follow across every Space
// (backend: app.setClickThrough/setLevel/setAllSpaces + app.window(id).*)

// grab the text selected in ANY app (PopClip-style popovers; Accessibility)
const sel = await tiny.macos.selectedText();   // string | null

// arrange other apps' windows (Rectangle/Magnet; Accessibility)
const wins = await tiny.macos.otherWindows();  // [{ app, pid, title, x,y,w,h }]
await tiny.macos.moveWindow(wins[0].pid, { x: 0, y: 0, width: 1280, height: 800 });

// anchor a dropdown under the tray icon
const spot = await tiny.tray.position();     // { x, y, width, height } | null

// render the page to a PDF (vector, WKWebView) — invoices, reports
const { path } = await tiny.win.printToPDF('/tmp/report.pdf');
// From another origin (a wrapped site), only Downloads, the app's data dir or
// the temp dir are written directly; any other path opens a save panel.

// a live app icon (render a canvas → progress rings)
tiny.app.icon(canvasPngPath);                // '' resets to the bundle icon

// battery + Wi-Fi for menu-bar monitors
const bat = await tiny.system.battery();        // { percent, charging, plugged,
                                             //   minutesRemaining } | null
const net = await tiny.system.wifi();           // { ssid, bssid, rssi, txRate }
                                             //   (ssid needs Location) | null

// find files by name or content (Spotlight, no mdfind spawn) — 100 paths max
const docs = await tiny.app.spotlight('quarterly report');

// on-device LLM — Apple's FoundationModels (offline, no API key, private).
// Needs macOS 26 AND Apple Intelligence switched on, so ALWAYS check
// availability() first — three states, and only one of them can generate.
// TOOL CALLING (backend only — a tool's run() is a real function, so it
// can't cross the bridge from a page). The model decides what to call:
const { text, calls } = await app.macos.ai.generate('Move the window to 200, 120', {
  instructions: 'You control a desktop app window. Use the tools.',
  tools: [{
    name: 'moveWindow',
    description: 'Move the application window to a position on screen.',
    parameters: { x: { type: 'integer', description: 'x in points' },
                  y: { type: 'integer', description: 'y in points' } },
    run: ({ x, y }) => { app.window('main').setPosition(x, y); return 'moved'; },
  }],
});
// `calls` is the RECORD; `text` is a summary that may be fiction. Measured on
// macOS 26.5: asked for three tool calls in one turn, this model made all
// three in one run out of four — and claimed all three in its prose every
// time, including the runs where it silently skipped one. Put anything
// irreversible behind a confirmation, not behind a hopeful read of `text`.

if (await tiny.macos.ai.availability() === 'available') {
  const reply = await tiny.macos.ai.generate('Summarise this in one line: ' + text,
    { instructions: 'You are terse.' });   // instructions = a system prompt
}

// native file dialogs (NSOpenPanel/NSSavePanel, run by the launcher)
const file  = await tiny.dialog.openFile();     // path | null
const files = await tiny.dialog.openFiles();    // paths[] | null
const dir   = await tiny.dialog.pickFolder();   // path | null
const dest  = await tiny.dialog.saveFile();     // path | null
// openFile/openFiles/saveFile take { types: ['md', 'txt'] } — extensions,
// no dots — to limit what's choosable (allowedContentTypes on macOS,
// COMDLG_FILTERSPEC on Windows, GtkFileFilter on Linux; the latter two add
// an "All files" escape hatch). Omit types and everything is selectable.
const md = await tiny.dialog.openFile({ types: ['md', 'markdown', 'txt'] });
// saveFile({ name }) pre-fills the file name: a name, not a path (any
// folder part is dropped). With types, the extension goes on as usual.
const doc = await tiny.dialog.saveFile({ types: ['docx'], name: 'report' });  // …/report.docx

// native system dialogs (NSAlert)
await tiny.dialog.alert('Heads up', 'optional detail');
const ok   = await tiny.dialog.confirm('Delete everything?', { detail: '…', ok: 'Delete', cancel: 'Keep' });
const name = await tiny.dialog.prompt('Your name?', { default: 'world' });  // string | null

Menus

tiny.menu.set([
  { title: 'Actions', items: [
    { id: 'open',  label: 'Open File…', key: 'o' },   // key = ⌘+<key>
    { id: 'find',  label: 'Replace…', key: 'alt+f' }, // ⌥⌘F ('F' alone = ⌘⇧F)
    { id: 'mute',  label: 'Mute', checked: true },    // ✓ checkmark
    { id: 'later', label: 'Not Yet', enabled: false },// grayed out
    { separator: true },
    { id: 'more',  label: 'More', submenu: [          // nests
      { id: 'a', label: 'Sub Item' },
    ]},
  ]},
]);
tiny.menu.on((id) => { ... });   // clicks; backend can also export onMenu(id, app)

// patch an item in place — no redeclaring:
tiny.menu.update('mute', { checked: false, label: 'Unmuted' });
const { exists, label, checked, enabled } = await tiny.menu.get('mute');

tiny.menu.set([
  { title: 'File', items: [...] },
  { role: 'edit' },                 // Undo / Cut / Copy / Paste / Select All
  { title: 'View', items: [...] },
]);

tiny.menu.set([
  { title: 'File', items: [...] },
  { role: 'edit', items: [
    { id: 'find', label: 'Find…', key: 'f' },
    { id: 'dup',  label: 'Duplicate', key: 'd' },
  ] },
]);

{ role: 'edit', items: [                // your items first, stock group below
  { id: 'find', label: 'Find…', key: 'f' },
  { separator: true },
  { role: 'standard' },
] }

{ role: 'edit', items: [                // just the stock items you want
  { role: 'undo' }, { role: 'redo' },
  { separator: true },
  { role: 'copy' }, { role: 'paste' },
] }

{ role: 'edit', standard: false, items: [{ id: 'find', label: 'Find…', key: 'f' }] }
{ role: 'edit', standard: false }       // no Edit menu at all

{ role: 'edit', items: [                // identical on macOS, Windows, Linux
  { role: 'standard' },
  { separator: true },
  { id: 'find', label: 'Find…', key: 'f' },
] }

const mac = tjs.env.OS !== 'Windows_NT'
  && !/linux/i.test(navigator.platform ?? '');

tiny.menu.set([
  ...(mac ? [{ role: 'app', items: [
    { id: 'settings', label: 'Settings…', key: ',' },
  ] }] : []),
  { title: 'File', items: [
    ...(mac ? [] : [{ id: 'settings', label: 'Settings…', key: ',' }]),
  ] },
  { role: 'edit' },
]);

app.menu.set([
  { title: 'File', items: [/* … */] },
  { role: 'help', items: [
    { id: 'site', label: 'Visit Website' },
    { id: 'issue', label: 'Report an Issue…' },
  ] },
]);

Multiple windows

tiny.win.open('settings', { page: 'settings.html', title: 'Settings', size: '420x300' });
tiny.win.id;                       // which window this page lives in
tiny.win.close();                  // close the calling window ('main' quits)
await tiny.win.windows();          // ['main', 'settings', ...]

// chrome + position are applied BEFORE the window paints — a frameless
// panel never flashes its titlebar, and it opens where you asked (not
// center-then-jump):
tiny.win.open('hud', { page: 'hud.html', size: '300x120', x: 40, y: 40,
                       chrome: { frame: false, windowControls: false, vibrancy: 'hud' } });

// parent keeps a window above another of YOUR windows — an about box or tool
// panel that can't get lost behind the window it belongs to, without floating
// over other apps the way setLevel('floating') would. true = 'main', or name
// a win.open id. It also minimizes/hides with its parent, closes when the
// parent closes, and on Windows/Linux gets no taskbar entry of its own.
// Open-time only (Windows ownership can't be set later). One cross-OS
// difference: on macOS the window also MOVES with its parent.
tiny.win.open('about', { page: 'about.html', size: '360x420', parent: true });

app.win.open('settings', { page: 'settings.html' });
app.window('settings').setTitle('…');   // eval, push, close, hide/show,
                                        // setSize/Position, chrome, getState…
app.push('event', data);                // broadcasts to every window
app.windows();
export function onWindowClosed(id, app) {}   // also a 'window-closed' event
export function onWindowState(info, app) {}  // { win, fullscreen, maximized,
                                             // minimized, focused } on every
                                             // transition — the backend twin
                                             // of tiny.win.onState

Deep links, file associations, single instance

{ "urlScheme": "myapp", "fileExtensions": ["md", "txt"] }

tiny.app.onOpenUrl((url) => ...);        // backend: export onOpenUrl(url, app)
tiny.app.onOpenFiles((paths) => ...);    // backend: export onOpenFiles(paths, app)

Tray (menu bar) apps

tiny.tray.set({
  title: 'MyApp',            // text in the menu bar (and/or an icon)
  icon: 'sf:cup.and.saucer.fill', // SF Symbol by name — or a png path ('tray.png')
  tooltip: 'My tiny app',    // pngs are template images by default
  menu: [                    // ({ template: false } keeps their colors)
    { id: 'show', label: 'Show Window' },
    { separator: true },
    { id: 'quit', label: 'Quit' },
  ],
});
tiny.tray.on((id) => { ... });        // menu clicks; backend: export onTray(id, app)
tiny.tray.remove();

// the full tray-app recipe:
tiny.win.setHideOnClose(true);        // closing the window hides it
tiny.app.presence('menubar');         // no Dock icon — menu-bar-only app

tiny.tray.set({ icon: 'sf:cup.and.saucer.fill', primaryAction: true,
                menu: [{ id: 'quit', label: 'Quit' }] });
tiny.tray.onClick(() => toggle());    // left click; backend: onTray(null, app)

{ "activation": "accessory" }

Windowless tray agents

{ "mainWindow": false, "activation": "accessory" }

export function init(app) {
  app.tray.set({ icon: 'sf:camera', menu: [
    { id: 'settings', label: 'Settings…' },
    { id: 'quit', label: 'Quit' },
  ] });
}

export function onTray(id, app) {
  if (id === 'settings') {
    app.win.open('settings', { page: 'settings.html', size: '600x400' });
    app.window('settings').show();
  }
  if (id === 'quit') app.quit();
}

Apps that place their own windows

{ "windowPlacement": true }

tiny.system.os()                     // 'macos' | 'windows' | 'linux'   (sync)
tiny.system.isMacOS()                // sync — as are isWindows() / isLinux(),
                                     // so a page can branch before first paint
await tiny.system.architecture()     // 'arm64' | 'x86_64' — must be awaited:
                                     // WKWebView says MacIntel on Apple silicon
await tiny.system.info()             // { os, arch, session, desktop }
const can = await tiny.system.capabilities();
if (!can.windowPosition) useDragInstead();   // e.g. tiny.win.startDrag()

Filtering your own audio

const can = await tiny.system.capabilities();
// One backend decision, then identical code: pageChain speaks the same verbs.
const eq = can.audioFilters ? tiny.audio : tiny.audio.pageChain(ctx);
if (eq.input) {                          // the page chain needs routing once
  source.connect(eq.input);
  eq.output.connect(ctx.destination);
}
await eq.filters([
  { type: 'gain', gain: 1.0 },                          // preamp (linear)
  { type: 'peaking', freq: 60, q: 1.1, gain: 4 },       // dB
  { type: 'highshelf', freq: 8000, q: 0.7, gain: -2 },
]);
eq.filter(1, { gain: -3 });   // retune one, live, no gap
await eq.clear();             // remove

Missing system packages

const [aac] = await tiny.system.requirements(['media.aac']);
// -> { id, ok, feature, detail, install: { manager, packages, command } }

// the same thing with the satisfied ones dropped — the common case, and
// empty on macOS/Windows, where all of it ships with the OS
const gaps = await tiny.system.missing();

audio.addEventListener('error', () => tiny.system.promptMissing(['media.aac']));

const [aac] = await tiny.system.requirements(['media.aac'], { refresh: true });

Build for release

tinyjs build

Bundled data resources

my-app/
  resources/
    dictionary.json
    fonts/

export async function init(app) {
  const root = (await app.paths()).resources;
  if (root === null) return;
  const bytes = await tjs.readFile(root + '/dictionary.json');
  console.log(new TextDecoder().decode(bytes));
}
// Frontend: the existing RPC returns the same root.
const paths = await tiny.app.paths();
console.log(paths.resources); // string | null

{
  "resources": ["dictionary.json", "fonts/"],
  "windows": { "resources": ["dictionary.json", "fonts/", "win-only.dat"] }
}

{
  "resources": [],                                  // Windows, Linux: nothing
  "macos": { "resources": ["mac-only.png"] }        // macOS: just this
}

Bundled executables (sidecars)

my-app/
  executables/
    my-cli.exe            # Windows (PE): only Windows builds ship it
    my-cli                # macOS (Mach-O, universal)
    linux/my-cli          # Linux's own my-cli, since the name clashes
    linux-arm64/my-cli    # …and the arm64 one, for arm64 builds

export async function init(app) {
  const dir = (await app.paths()).executables;   // string | null
  const exe = dir + '/my-cli' + (tjs.env.OS === 'Windows_NT' ? '.exe' : '');
  const p = tjs.spawn([exe, '--version'], { stdout: 'pipe' });
  // …read p.stdout, then await p.wait()
}
// Frontend: (await tiny.app.paths()).executables is the same folder.

{
  "executables": ["my-cli.exe"],
  "macos": { "executables": ["mac/my-cli", "mac/helper"] },
  "linux": { "executables": ["linux/"] }
}

{
  "macos": {
    "executableEntitlements": {
      "my-cli": ["com.apple.security.cs.allow-jit",
                 "com.apple.security.cs.allow-unsigned-executable-memory",
                 "com.apple.security.cs.disable-library-validation"]
    }
  }
}

App assets

{ "macos": { "helpBook": "My App Help" } }

Distributing to other people (Developer ID + notarization)

Shipping updates (auto-update)

{ "name": "myapp", "version": "1.1.0",
  "update": { "url": "https://example.com/myapp/manifest.json" } }

const { available, latest, notes } = await tiny.app.update.check();
if (available) await tiny.app.update.install();   // downloads, verifies
// sha256 + code signature, swaps the .app in place, relaunches

tiny.api.on('update-available', async ({ latest, notes }) => {
  if (await tiny.dialog.confirm(`Update to ${latest}?`, { detail: notes ?? '' }))
    await tiny.app.update.install();
});

Why the .app looks the way it does (codesigning)

MyApp.app/Contents/
  MacOS/myapp            the launcher (CFBundleExecutable) — window process,
                         spawns tjs
  MacOS/tjs              stock runtime binary — signs cleanly
  Resources/app/         entry.js, bridge.js, update.js, frontend/, src/…
                         (plain data, sealed by the bundle signature)
  Resources/AppIcon.icns

How it works

┌──────────────────────┐  unix socket   ┌──────────────────────────┐
│ backend (txiki.js)   │◄──────────────►│ launcher (C++, ~1–2 MB)  │
│ your src/main.js     │  line protocol │ native/launcher-macos.cc │
│ + runtime/bridge.js  │                │ · WKWebView window       │
│ · owns app logic     │                │ · webview_bind bridge    │
│ · fs/net/process API │                │ · native dialogs         │
│ · spawns launcher    │                │ · else: dumb forwarder   │
└──────────────────────┘                └──────────┬───────────────┘
                                                   │ window.__invoke / eval
                                        ┌──────────▼────────────┐
                                        │ your page (file://)   │
                                        │ api.call('m', params) │
                                        │ api.on('event', fn)   │
                                        └───────────────────────┘

Wire protocol (newline-delimited; payloads are JSON so never contain raw \n)

Developing tinyjs itself

bin/tjs               txiki.js runtime (fetched by setup.sh, not committed;
                      bin/tjs.exe on Windows via setup.ps1)
native/launcher-macos.cc  the macOS window process (Objective-C++; webview
                      headers vendored)
native/launcher-win.cc  the Windows window process (WebView2 via the same
                      vendored webview; named pipe instead of a Unix socket)
native/launcher-linux.cc  the Linux window process (GTK3 + WebKitGTK 4.1
                      directly, no vendored webview; Unix socket, same as macOS)
native/make-icon.jxa  default template icon generator (osascript -l JavaScript)
runtime/bridge.js     backend bridge library (socket, protocol, win.* methods)
runtime/update.js     app auto-update (manifest check, verify, bundle swap)
template/             what `tinyjs new` copies
skill/SKILL.md        tinyjs reference for coding agents (copied into new
                      projects at .claude/skills/tinyjs/ and, for other
                      agents, .agents/skills/tinyjs/)
cli.js + tinyjs       the CLI (tinyjs.cmd is the Windows wrapper; Git Bash
                      on Windows uses the sh wrapper tinyjs)
test/smoke.html       self-driving test page
docs/                 tinyjs.app site (GitHub Pages): landing page + installer
                      (docs/install is what `curl tinyjs.app/install` fetches)
                      + changelog.html (tinyjs.app/changelog)
CHANGELOG.md          release history (canonical; the site page mirrors it)
setup.sh              from-source bootstrap (fetch tjs, compile natives) —
                      handles both macOS and Linux, branching on `uname`
setup.ps1             the same for Windows (also fetches the WebView2 header)
TODO-windows.md       remaining Windows-port work, ordered (tick items off
                      as they land)
TODO-linux.md         remaining Linux-port work, ordered (tick items off
                      as they land)
.github/workflows/    release automation: tag vX.Y.Z → universal binaries →
                      per-arch tarballs + checksums → GitHub release

Testing

cd someproject
TINYJS_HTML=/path/to/tinyjs/test/smoke.html tinyjs dev
# expect: [web] SMOKE RESULTS {...} with no FAIL entries, clean exit

Gotchas discovered along the way (txiki.js v26.6.0)

On-device AI (tiny.macos.ai)

if (await tiny.macos.ai.availability() === 'available')
  await tiny.macos.ai.generate(prompt, { instructions });

Portability

Windows

Linux

Future explorations

A slimmer txiki.js

scriptc as a backend

Credits