Build a Standalone Desktop Executable with WebviewJS

The WebviewJS CLI’s --build command delegates to the selected runtime’s executable compiler. The resulting executable includes the chosen runtime and your application code, but the WebviewJS native addon remains platform-specific and the target still needs its native webview prerequisites. The CLI is not an installer, package manager, or full application bundler. It does not add the matching platform-specific WebviewJS .node addon to the executable for you, so make that addon available to the built application when you distribute it.

The CLI is available as both the webview command and the webviewjs command. Both are identical — use whichever name is more convenient.

Install the CLI

Install the package globally to add the webview and webviewjs commands to your PATH, or use npx for one-off builds without a global install.

# Global install
npm install -g @webviewjs/webview

# One-off with npx (no global install needed)
npx --package=@webviewjs/webview webview --build --input src/index.js --name myapp

Quick start

Point the CLI at your entry file, give the output binary a name, and let it build.

webview --build --input src/index.js --name myapp

The executable is written to dist/ by default. On Windows a .exe extension is added automatically.

Choosing a runtime

Use --runtime (short: -R) to select the compilation tool. When --runtime is omitted, the CLI infers the runtime from its own execution environment: bun if run under Bun, deno if run under Deno, and node otherwise. For most users running via npm or npx, the default is node.

Node.js (default)
Deno
Bun

Node.js compiles via the Single Executable Application (SEA) workflow. The CLI generates the SEA blob, injects it with postject, and invokes codesign --sign - on macOS or tries signtool on Windows. Windows signing failures are reported as warnings; macOS signing failures can stop the build. Signing still depends on the platform tools and credentials available on the build machine.

webview --build --runtime node --input src/index.js --name myapp --output dist

The build invokes npx postject and the platform signing tools described above.

Requires deno on your PATH. Uses deno compile to produce a self-contained binary that bundles the Deno runtime.

webview --build --runtime deno --input src/index.ts --name myapp --output dist

The CLI runs:

deno compile --allow-all --no-check --output dist/myapp src/index.ts

--allow-all grants all Deno permissions. Restrict them in your own build script if needed.

Requires bun on your PATH. Uses bun build --compile to produce a standalone runtime executable for the build platform.

webview --build --runtime bun --input src/index.ts --name myapp --output dist

The CLI runs:

bun build --compile src/index.ts --outfile dist/myapp

On Windows, Bun appends .exe automatically if the name does not already include it.

All CLI options

Flag	Short	Default	Description
`--build`	`-b`	—	Build the project into a standalone executable
`--runtime`	`-R`	inferred	Runtime: `node`, `deno`, or `bun` (defaults to the current runtime)
`--name`	`-n`	`webviewjs`	Output executable name
`--input`	`-i`	`./index.js`	Entry file path
`--output`	`-o`	`./dist`	Output directory
`--resources`	`-r`	—	JSON asset map file path (Node.js runtime only)
`--dry-run`	`-d`	—	Print what would be done without executing
`--help`	`-h`	—	Show help text
`--version`	`-v`	—	Show the CLI version

Run --dry-run before a real build to preview the selected input, output, and runtime without invoking the compiler. It validates the runtime name and prints a summary; it does not check that files exist or print each compiler command.

webview --build --runtime node --input src/main.js --name myapp --dry-run

Bundling assets (Node.js only)

Node.js SEA supports embedding static assets in the binary via the --resources flag. Create a JSON file that maps asset names to file paths on disk. assets.json

{
  "icon.png":    "./assets/icon.png",
  "config.json": "./config.json"
}

Pass the file to the CLI:

webview --build --runtime node --resources assets.json --input src/index.js --name myapp

Inside your script, read the embedded assets with the node:sea API:

const { getAsset } = require('node:sea');

const iconBuffer  = getAsset('icon.png');
const configBytes = getAsset('config.json');
const config      = JSON.parse(Buffer.from(configBytes).toString('utf8'));

Asset bundling is only available with the Node.js runtime. Deno and Bun do not use the --resources option; use their runtime-specific packaging behavior.

Platform notes

Platform	Node SEA	Deno compile	Bun compile
Windows	`.exe`; CLI tries `signtool` and warns on failure	`.exe`; sign externally if required	`.exe`; sign externally if required
macOS	CLI invokes ad-hoc `codesign`	Sign externally if required	Sign externally if required
Linux	Standalone executable	Standalone executable	Standalone executable

Cross-compilation:

The WebviewJS CLI does not provide cross-compilation. Build on the target operating system and architecture, or prepare the matching WebviewJS native addon and runtime toolchain manually before packaging.

Installation — system requirements and first-time setup
Quick Start — build and run your first WebviewJS window

Get Started

Guides

Platform Notes

Build a Standalone Desktop Executable with WebviewJS

Install the CLI

Quick start

Choosing a runtime

All CLI options

Bundling assets (Node.js only)

Platform notes

​Install the CLI

​Quick start

​Choosing a runtime

​All CLI options

​Bundling assets (Node.js only)

​Platform notes

​Related pages

Install the CLI

Quick start

Choosing a runtime

All CLI options

Bundling assets (Node.js only)

Platform notes

Related pages