tinyjs
tinyjs is a JavaScript framework for building native desktop applications across macOS, Windows, and Linux in approximately 6 MB, using the OS's built-in webview and txiki.js runtime instead of bundling Chromium. The framework provides zero-port RPC communication between frontend and backend, full system access via txiki.js (files, sockets, processes, FFI, SQLite), and hot reload during development. Agencies use tinyjs to build custom desktop tools for clients, wrap existing web applications with native capability gates, or deliver productized services requiring lightweight cross-platform distribution. Unlike Electron (150+ MB) or Tauri (Rust backend, requires compilation), tinyjs keeps the entire application footprint small while maintaining JavaScript throughout the stack.
tinyjs is an AI code tool, integrating with WebKit, WebView2, WebKitGTK, and txiki.js. InnovaAI scores it 5.3/10 for agency resale.
Agency Audit
tinyjs produces cross-platform desktop apps that weigh roughly 6 MB by routing all UI through the OS's built-in webview (WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux) instead of bundling Chromium. Agencies that already build in React, Vue, Svelte, or Solid can ship signed, notarization-ready macOS bundles and Windows installers without learning Rust or maintaining a separate build pipeline. The strongest resell case is productized-service agencies that want to wrap a hosted web app with a native capability gate, giving clients a desktop presence without a full rebuild. Linux support is currently in beta, which limits deployment guarantees for clients on that platform.
5.3/10
Depends on volume
2d 1-2 days
- Your agency delivers productized desktop tools and needs signed, notarization-ready macOS bundles without adding a Rust or C++ build step to your pipeline.
- Your team already writes frontends in React, Vue, Svelte, or Solid and wants hot reload during development without a separate build step in dev.
- You need to wrap an existing hosted web app with a native capability gate so clients get file system, socket, and process access that a browser tab cannot provide.
- Your clients run Linux as a primary platform, because Linux support is currently in beta and carries no stability guarantee for production deployments.
- Your agency lacks developers comfortable with txiki.js or willing to learn a non-Node.js JavaScript runtime, since the backend layer is not interchangeable with standard Node.
- You need a white-label delivery mechanism with branded portals or reseller dashboards, because no verified white-label program appears in tinyjs documentation.
Profit Path
Estimate available after setup inputs
$1K–$3K/project
Monthly Recurring
Planning benchmark at United States price levels. Not a measured market survey.
Platform Features
Core capabilities of tinyjs
Native webview rendering across platforms
Renders UI in WebKit on macOS, WebView2 on Windows, and WebKitGTK on Linux, eliminating the need to bundle Chromium. Agencies deliver 6 MB applications instead of 150+ MB Electron builds, reducing client download friction and storage overhead.
JavaScript backend with full system access
Backend runs on txiki.js, providing file I/O, socket operations, process spawning, FFI, SQLite, fetch, and WebSocket capabilities without HTTP server overhead. Enables agencies to build feature-rich desktop tools that interact directly with the OS.
Zero-port RPC communication
Frontend and backend communicate over a Unix socket in a private temp directory instead of listening on network ports. Eliminates port collisions and network scanning surface area, simplifying deployment for client environments with strict firewall rules.
Hot reload for rapid development
Frontend edits swap into the live window and backend edits restart the process without a build step during development. Reduces iteration time for agencies building custom tools, shortening client project timelines.
Signed and notarization-ready bundling
tinyjs build command outputs codesigned application bundles ready for macOS notarization and Windows signing. Agencies deliver production-ready installers without manual code-signing workflows.
Wrap hosted web applications
Point the window at a URL to run existing web apps as native desktop clients with native dialogs, file panels, and downloads. Capability gates control which native APIs the origin can access, enabling agencies to add desktop distribution to existing SaaS products.
What Makes tinyjs Different
Unique advantages vs similar tools in this niche
JavaScript backend with no compile step
vs Tauri's Rust backend requires compilationThe backend is JavaScript, not Rust, so there is no compile step and no second language in the project.
OS features built into the API
vs Tauri requires plugins for dialogs, clipboard, notifications, etc.The OS surface, dialogs, menus, tray, clipboard, keychain, notifications, global hotkeys, auto-update, is just the API, not plugins you add one at a time.
Zero ports and no localhost server
vs Neutralino uses a localhost websocket servertinyjs uses a Unix socket in a 0700 temp dir, so nothing listens, nothing collides, nothing to scan.
~6 MB app size
vs Electron apps are ≥150 MBThe same app is ~6 MB because it uses the OS's webview and a 5.6 MB JS runtime.
Latest Updates
Recent releases and improvements for tinyjs
No display now fails fast, loud, and diagnosably, on all three platforms
Improvement2026-08-24Each launcher now checks its environment before connecting to the backend and prints a tinyjs:-prefixed explanation, exiting with code 3 before socket connect on headless Linux, SSH'd Mac, or Windows service sessions.
Docs: the tjs.*-async / tjs:sqlite-sync footguns are now written down
Improvement2026-08-24Documentation added covering Promise-based fs calls vs synchronous sqlite, unawaited makeDir race conditions, and better-sqlite3 differences including run()/all()/finalize() and last-insert-id idioms.
macOS: a frameless secondary window is really frameless
Fix2026-08-18Fixed a bug where windows opened with chrome: { frame: false, windowControls: false } kept a live titlebar container whose rounded top edge drew over the page and swallowed mouse events.
{ role: 'app' } puts items in the macOS application menu
New2026-08-06Items declared in an app role block now land between About and Quit in the macOS application menu, supporting Settings… (⌘,) and other standard items. Windows and Linux drop the role rather than placing items arbitrarily.
Wrap a hosted web app as a real desktop app
New2026-08-06"url" in tinyjs.json makes the main window a remote page, adding native alert/confirm/prompt panels, downloads, window.open configurability, navigation events with veto support, find-in-page, an API capability gate, and an inject option for shimming wrapped sites.
Value Equation
Outcome-likelihood-time-effort assessment for tinyjs
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. tinyjs has no published pricing, so we hold this section until real numbers are available.
Contact tinyjsPricing
Platform cost for tinyjs
Custom pricing
tinyjs uses custom/enterprise pricing: rates aren't published publicly. Contact their team directly for a quote.
Contact tinyjsMarket Intelligence
Offer + scale economics for tinyjs
Offer economics require real pricing
Offer economics, scale projections, and margin potential all depend on tinyjs's actual platform cost. Once pricing is published or shared with your agency, we'll compute the full breakdown here.
Contact tinyjsInvestment Decision Framework
Strategic vetting analysis for tinyjs
Consider
Favorable fit, worth a closer look
Buy If
5Your agency delivers productized desktop tools and needs signed, notarization-ready macOS bundles without adding a Rust or C++ build step to your pipeline.
Your team already writes frontends in React, Vue, Svelte, or Solid and wants hot reload during development without a separate build step in dev.
You need to wrap an existing hosted web app with a native capability gate so clients get file system, socket, and process access that a browser tab cannot provide.
App bundle size is a client deliverable constraint, and you need to ship under 10 MB on macOS and Windows without stripping features.
You want coding-agent workflows where the tool generates skill files so agents already understand the full tinyjs API without manual documentation.
Skip If
4Your clients run Linux as a primary platform, because Linux support is currently in beta and carries no stability guarantee for production deployments.
Your agency lacks developers comfortable with txiki.js or willing to learn a non-Node.js JavaScript runtime, since the backend layer is not interchangeable with standard Node.
You need a white-label delivery mechanism with branded portals or reseller dashboards, because no verified white-label program appears in tinyjs documentation.
Your client projects require a traditional HTTP server or port-based inter-process communication, since tinyjs routes all page-to-backend traffic over a Unix socket with zero open ports by design.
Bottom Line
tinyjs produces cross-platform desktop apps that weigh roughly 6 MB by routing all UI through the OS's built-in webview (WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux) instead of bundling Chromium. Agencies that already build in React, Vue, Svelte, or Solid can ship signed, notarization-ready macOS bundles and Windows installers without learning Rust or maintaining a separate build pipeline. The strongest resell case is productized-service agencies that want to wrap a hosted web app with a native capability gate, giving clients a desktop presence without a full rebuild. Linux support is currently in beta, which limits deployment guarantees for clients on that platform.
Reality Check
Linux support is explicitly labeled beta, so agencies with clients on Linux distributions cannot guarantee a stable shipping target. The JavaScript backend runs on txiki.js, a runtime most agency developers will not know, meaning onboarding junior staff requires ramp-up time beyond standard Node.js familiarity.
Low effort: self-service setup with guided onboarding
Academy for tinyjs
Work through it in order: the course for this service first, then the modules behind it.
No Academy modules are published for this service yet. Browse the full Academy
Why this category matters
The commercial case before the tooling.
Core concepts
The mental model you need to price and scope the work.
- Scaffold, Don't SubstituteConcept
Scaffold, Don't Substitute is a framework for agencies adopting AI code tools: use them to generate scaffolding and handle maintenance, but never as a replacement for human architectural oversight. The strategic insight from the category description warns that over-reliance risks code quality inconsistency and vendor lock-in. For example, an agency might use Verdent to rapidly prototype a full-stack app from a natural language brief, then have senior engineers review and refactor the generated code before delivery. Similarly, Ripple can auto-fix consumer code when APIs break, but a human must verify the changes align with client contracts. This framework helps agencies capture speed advantages while protecting quality and client trust. It also aligns with recent market data showing that AI agent loops can run 100x cheaper via simulation, but accuracy tradeoffs demand human judgment for high-stakes tasks.
- Human Checkpoint RatioConcept
The Human Checkpoint Ratio is the proportion of AI-generated code that passes through human review before delivery. Agencies adopting AI code tools often see speed gains, but unchecked automation can introduce subtle bugs and architectural drift. The framework holds that the optimal ratio depends on task risk: scaffolding and boilerplate can run nearly autonomous, while core business logic and client-facing features demand human sign-off. For example, HumanLayer structures workflows with six phases, each requiring human checkpoints, ensuring alignment and early error catching. Similarly, Ripple automates API break fixes but relies on developers to review generated pull requests. Agencies should define explicit checkpoints per task type, balancing speed with quality. A 100x cost reduction in simulation-based agents, as reported by Marktechpost, suggests that high-volume, low-stakes tasks can tolerate lower ratios, freeing human oversight for critical paths.
- Maintenance Over BuildConcept
AI code tools shift agency value from greenfield builds to ongoing maintenance. Platforms like Ripple auto-fix breaking API changes across repos, while Verdent generates full-stack apps from prompts, making initial builds cheap and commoditized. The durable margin lies in keeping client systems healthy: dependency updates, security patches, and refactors. Agencies that sell maintenance retainers, not just launch fees, convert a one-off project into recurring revenue. A 100x cost reduction in agent loops, as reported in simulation research, makes automated upkeep affordable at scale. The framework: use AI for scaffolding and repairs, but anchor the commercial model on continuous care, where human oversight prevents the quality drift that pure automation introduces.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Code Tools Rule: Scaffold Fast, Architect SlowEvaluation Rule
Use AI code tools for scaffolding and maintenance tasks, but keep human architectural oversight for production decisions.
- AI Code Tools Rule: When Delivery Speed Is the Bottleneck, Automate Maintenance Before Greenfield BuildsEvaluation Rule
Use AI code tools for scaffolding and maintenance automation first, and reserve human architects for greenfield design and final review.
- The Scaffolding-Only Trap: Why AI Code Tools Stall in Agency DeliveryFailure Pattern
- The Unreviewed Merge Trap: Why AI Code Tools Fail in Agency DeliveryFailure Pattern
8 modules selected for tinyjs
Frequently Asked Questions
Answers about pricing, setup, implementation, and more
tinyjs is a framework for building native desktop applications using JavaScript, leveraging the OS's built-in webview (WebKit, WebView2, or WebKitGTK) and a txiki.js backend runtime. It delivers cross-platform apps in approximately 6 MB without bundling Chromium, provides full system access via the backend, and communicates between frontend and backend over a Unix socket with zero network ports. Agencies use it to build custom desktop tools, wrap existing web applications with native capabilities, and deliver lightweight client applications.
tinyjs is open-source and MIT-licensed. No pricing is charged for the framework itself. Agencies may incur costs only if they use commercial support or hosting services, which are not detailed in the available documentation.
tinyjs is a development framework, not a white-label platform. Agencies build custom applications using tinyjs and deliver them under their own branding or the client's branding. The framework itself does not impose branding constraints on the final application.
Yes. tinyjs uses WebKit natively on macOS, WebView2 on Windows, and WebKitGTK on Linux. These are not integrations but the core rendering layer; the framework is built around them. Agencies do not configure these separately.
Initial setup depends on the client's requirements. A basic tinyjs project scaffold can be created in minutes using the CLI. Development time varies based on feature complexity, but hot reload during development accelerates iteration. No multi-tenant onboarding overhead exists since tinyjs is a build framework, not a managed service.
tinyjs suits agencies building custom desktop tools for software development teams, media production workflows (amp example demonstrates audio playback and visualization), internal business applications, and productized services that require lightweight cross-platform distribution. It is less suitable for consumer-facing applications requiring extensive third-party integrations or agencies without JavaScript backend expertise.
Linux support is currently in beta. macOS and Windows are production-ready. Agencies targeting enterprise clients requiring stable multi-platform support should verify Linux stability for their specific use case before committing to client contracts.
Yes. Point the window at a URL and tinyjs behaves like a browser, rendering the hosted application with native dialogs, file panels, and downloads. A capability gate controls which native APIs that origin can access, allowing agencies to add desktop distribution to existing SaaS products while controlling security boundaries.