What's new

Stable Release

The first stable release of jiki — a lightweight, browser-based Node.js runtime.

What’s Included

• Virtual filesystem with POSIX-like API, symlinks, watching, and persistence
• CommonJS kernel with module caching and circular dependency handling
• npm package manager with pnpm support, workspaces, and caching
• Shell with pipes, globs, job control, history, and tab completion
• esbuild-wasm transpiler for TypeScript and JSX
• Dev servers for Vite, Next.js, SvelteKit, and Remix
• Plugin system with 6 hook types
• Sandboxing with resource limits
• Performance metrics and network mocking
• TypeScript type checker (heuristic)
• 30 examples covering frameworks, servers, testing, tools, and AI
• jiki-ui React component library

Getting Started

npm install @run0/jiki

import { boot } from "@run0/jiki";

const container = boot();
await container.init();

container.vfs.writeFileSync("/index.js", 'console.log("Hello from jiki!")');
const result = await container.run("/index.js");
console.log(result.stdout); // "Hello from jiki!"

Plugin System

Hook-based plugin system that lets you intercept and extend jiki at key points. API mirrors esbuild conventions.

• onResolve — intercept module resolution
• onLoad — provide virtual file contents
• onTransform — modify source code in a pipeline
• onCommand — register custom shell commands
• onInstall / onBoot — lifecycle hooks

const container = boot({
  plugins: [{
    name: "virtual-config",
    setup(hooks) {
      hooks.onResolve(/^@env$/, () => ({ path: "/__env__.js" }));
      hooks.onLoad(/^\/__env__\.js$/, () => ({
        contents: 'module.exports = { NODE_ENV: "production" };',
      }));
    },
  }],
});

Persistence

IndexedDB persistence for the virtual filesystem. Writes are fire-and-forget with batched flushing.

Sandboxing

Configurable resource limits for untrusted code: memory caps, file count limits, network allowlists, and filesystem path restrictions.

jiki-ui

React component library with CodeEditor (Shiki syntax highlighting), Terminal, BrowserWindow, FileExplorer, AIChatPanel, and MobileTabBar.

Shell

Full shell implementation with command parsing, pipes (|), logical operators (&&, ||), semicolons, redirects (>, >>), glob expansion (**/*.ts), brace expansion (*.{js,ts}), background jobs (&), command history, and tab completion.

Container API

The boot() function provides the main entrypoint for initializing and managing the runtime. Orchestrates VFS, kernel, package manager, shell, and dev servers.

import { boot } from "@run0/jiki";

const container = boot({ cwd: "/app" });
await container.init();
await container.run("index.ts");

Dev Servers

• Vite: ESM-based module serving with HMR, /@modules/ bare import resolution, and CSS-as-JS injection
• Next.js: File-based routing with Pages Router and App Router, API routes, and SSR
• SvelteKit: File-based routing with +page.svelte, +layout.svelte, and +server.ts
• Remix: Flat file routing with dot-delimited nesting

Error Handling

Smart error messages with actionable fix suggestions for common issues like missing modules, undefined references, and configuration errors.

Package Management

Full npm-compatible package manager running entirely in the browser.

npm Registry Client

Fetches package metadata and tarballs from the npm registry. Supports scoped packages, version ranges, and tag resolution.

Dependency Resolution

Semver-aware dependency resolver with support for ^, ~, >=, and exact version ranges. Handles nested dependencies with deduplication.

pnpm Support

Content-addressable store layout matching pnpm conventions. Packages are stored once and hardlinked into project node_modules.

Workspaces

Discover and link workspace packages from package.json workspaces fields or pnpm-workspace.yaml. Supports workspace: protocol for local dependencies.

Module System

CommonJS kernel execution engine with full require() support, module caching, and circular dependency handling.

Module Resolver

Node.js-compatible module resolution supporting:

• Relative paths (./, ../)
• Directory index files (index.js, index.ts)
• Package.json main, module, and exports fields
• Builtin module resolution

Transpiler

esbuild-wasm integration for TypeScript and JSX with lazy WASM loading. Supports .ts, .tsx, .jsx file extensions with automatic format detection.

Polyfills

24 Node.js polyfills including fs, crypto, http, net, os, zlib, child_process, readline, tty, vm, and more.

Virtual Filesystem

The foundation of jiki — an in-memory virtual filesystem (MemFS) with Node.js-compatible semantics.

Features

• Full directory tree with mkdir, readdir, rmdir, and recursive operations
• Symlink support with symlink, readlink, and automatic resolution
• File watching via watch with change event notifications
• Snapshot serialization for saving and restoring VFS state
• POSIX-like path resolution with . and .. handling
• Stats objects with isFile(), isDirectory(), isSymbolicLink()

Core Polyfills

Polyfills for essential Node.js modules: path, events, process, stream, assert, util, url, and querystring.