What we're building

In-browser git implementation: clone, commit, push, pull, branch, merge, and diff operations backed by the virtual filesystem.

Mount external filesystems into MemFS: host FS bridges, IndexedDB volumes, pre-built snapshots, and lazy-loaded directory trees.

First-class .wasm module support: load and execute WebAssembly binaries (ffmpeg, ImageMagick, SQLite, custom modules) with proper FS and memory bridging.

Built-in grep command in the kernel/shell with regex matching, recursive directory search, line numbers, and context lines (-A, -B, -C flags).

sql.js with persistence — schema creation, queries, and IndexedDB-backed storage.

Native WebSocket server and client APIs — replace the current ws stub with a functional implementation using MessageChannel or BroadcastChannel.

Move module resolution, require(), and code execution into Web Workers — currently only transpilation is offloaded.

WebSocket-to-TCP bridge, tunnel proxy for real domains, and Fetch API networking layer — run Next, Expo, Express with real domain access.

Support "use server" directive for form handling and server mutations — major gap in Next.js compatibility.

End-to-end project execution: npm/pnpm scripts with piped output, port exposure, dev server lifecycle, and multi-process orchestration.

Execute middleware.ts in the request pipeline for auth, redirects, and rewrites.

Multi-port discovery, custom domain mapping, port forwarding hooks, and UI integration for exposed dev server ports.

Global package installs, full npx lifecycle (cache, versioning, --yes), npm link, npm ls, npm outdated, and better flag handling.

Conditional client/server rendering based on "use client" / "use server" directives.

Global installs, full pnpm dlx lifecycle, pnpm exec, pnpm why, pnpm prune, and better flag/workspace handling.

Incremental Static Regeneration with revalidate timers for cached page responses.

Heap-aware eviction, streaming installs, GC hooks, and memory budget APIs to prevent browser tab crashes on large dependency trees.

Parallel routes (@slot), intercepting routes (..), and i18n routing support.

Better vm polyfill: iframe-based context isolation, execution timeouts, vm.compileFunction, source map offsets, and compilation caching.

pbkdf2, scrypt, and HKDF implementations for password hashing and key stretching.

Built-in grep, head, tail, wc, sort, uniq, xargs, curl, tar, and sed commands for the jiki shell.

Real inter-process communication between spawned child processes via stdio 'ipc' and child.send().

SIGTERM, SIGKILL, SIGINT semantics for graceful shutdown of child processes.

Provide examples and support for Tanstack libraries like React Query, Router, and Table. Create a full blown example of Tanstack Start.

fs.linkSync() / fs.link() alongside existing symlink support.

Functional chmod/chown with permission bit checking (currently no-ops).

path.win32 implementation for cross-platform path handling.

Plugin-based next/image handling beyond the current img fallback.

Move beyond stub implementation — full file-based routing, server routes, load functions, and HMR.

Complete the stub — loaders, actions, nested routes, error boundaries, and streaming.

Improve readline support for interactive prompts — Container.sendInput() works but isn't well-documented or robust.

Replace generic "Cannot find module" with contextual suggestions (did-you-mean, check node_modules, verify package.json).

Current vm.runInNewContext() shares the JS context — evaluate Realm API or iframe isolation for untrusted code.

Non-blocking require() for large dependency trees — currently synchronous and can block the main thread.

Cache-aware partial recompilation instead of full esbuild pass on every change.

Reduce noise from repeated warnings on unsupported modules (async_hooks, cluster, dgram, etc.) — warn once, then silence.

Extend beyond SHA family — add MD5 (legacy compat), BLAKE2, and proper randomUUID.

Move beyond hardcoded 127.0.0.1 — resolve against a configurable hostname map for dev server scenarios.

Include full stat fields (atime, ctime, mode) in snapshots — currently only mtime is preserved.

Use ArrayBuffer/Blob for binary content instead of base64 (33% storage overhead).

Make the 4000-module LRU limit configurable — large projects may need more, small ones waste memory.

Move from heuristic pattern matching toward proper type inference for common patterns (generics, union narrowing).

Better detection and error reporting for circular require() chains beyond the basic visited-set approach.

Kimi (Moonshot AI) integration mirroring the Claude/Mistral examples — expands AI model coverage to a third provider.

Remix with loaders, actions, nested routes, and error boundaries — showcases the full dev server.

SolidJS with fine-grained reactivity — expands framework coverage beyond React/Vue/Svelte.

Apollo Server schema execution + Apollo Client queries in a single container.

Browser-based test runner showing component testing with assertion visualization.

Create, build, and test an npm package end-to-end — package.json, TypeScript compilation, test suite.

Scaffold new jiki projects or recreate examples with npm create jiki@latest.

Side-by-side Claude vs Mistral vs Kimi — same prompt, different models, compare outputs.

pnpm workspaces with React + Vue + shared utils — demonstrates cross-framework workspace linking.

Lint and format pipeline — configure rules, run checks, auto-fix.

Minimal SSG from scratch — markdown parsing, template rendering, file output.

Vanilla custom elements with Shadow DOM — no framework, pure browser APIs.

Fastify with schema validation, serialization, and plugin system.

Astro is a supported framework with an example but has no dedicated guide (React, Next.js, Vue, Vite all have guides).

pnpm layout, workspaces, and differences from npm — currently mentioned but not explained in depth.

Interactive stdin is shipped but sendInput() is not documented in the Container API reference.

registerPolyfill() is briefly mentioned — needs a guide on creating and registering custom Node.js polyfills.

parseError() and formatErrorHtml() are referenced in errors.mdx but lack full API documentation.

Svelte has an example and dev server but no dedicated getting-started guide.