wjsm

The description states that wjsm is an AOT JavaScript/TypeScript runtime. It does not interpret JS bytecode or embed V8. Instead, it:

• Parses JS/TS with swc_core
• Lowers the AST into a custom SSA-style IR
• Compiles that IR to WebAssembly using wasm-encoder
• Executes modules via wasmtime plus a host runtime for objects, GC, timers, promises, Node-ish APIs, and debugging

It supports commands such as:

• wjsm run app.ts
• wjsm build app.ts -o app.wasm
• wjsm check app.ts
• wjsm eval "1 + 2"

The system is described as having:

• Control flow, classes, closures, exceptions, iterators, async/await
• ESM/CJS bundling and package resolution
• Streams / fetch-shaped host surfaces
• node:vm multi-realm execution
• node:async_hooks
• Chrome DevTools Protocol-style --inspect / --inspect-brk

The runtime uses:

• NaN-boxed i64 values for JS types
• Handle-based heap with pluggable GC algorithms (mark-sweep, G1, ZGC)
• Build-time embedded primordial snapshot to reduce cold start times

This is a technical implementation of a JavaScript engine built on AOT compilation principles.

The author positions wjsm as an alternative to traditional JavaScript runtimes like V8, SpiderMonkey, Deno, and Bun. The core claim is that it treats JavaScript like a real programming language with a real compiler rather than embedding a mega-JIT engine.

Key claims:

• Predictable execution through AOT compilation
• Hard sandboxing via WebAssembly linear memory and capability boundaries
• Portable artifacts (WASM modules that can move with code)
• ECMAScript semantics as the source of truth, not partial implementations

The project evolved from a simple idea to a full-stack compiler/runtime stack. The author emphasizes:

• Spec-first culture
• Clean crate boundaries
• Multi-stage debugging and tooling support
• Node compatibility without becoming Node

There is no indication that wjsm has moved beyond its initial concept or expanded into a productized offering.

Not evidenced.

The description does not identify specific customer segments, target industries, or use cases beyond the author’s own development goals. It does not describe any existing users, customers, or personas who would be using wjsm in production or commercial settings.

Not evidenced.

There is no mention of pricing models, monetization strategies, licensing terms, or business structure. The project appears to be a personal or open-source effort with no indication of any commercial revenue streams or pricing mechanisms.

The description provides detailed technical information about the architecture:

• Stages: Parser (swc_core), Semantic Analyzer (AST → IR), Module bundler, WASM backend (wasm-encoder), Runtime (wasmtime + host imports)
• Value representation: NaN-boxed i64 with tag-based type system
• GC support: Pluggable algorithms including mark-sweep, G1, ZGC
• Startup optimization: Embedded primordial snapshot
• Debugging tools: IR/WAT dumps, stage isolation (--stage), CDP-style inspect hooks

It also mentions:

• ESM/CJS module resolution
• Node-compatible APIs (vm, async_hooks, inspector)
• Test262 conformance work and fixture/snapshot suites
• Engineering discipline: ADRs, nextest matrices, IR snapshots

These signals suggest a mature technical foundation built with engineering rigor.

Not evidenced.

There is no evidence of:

• Revenue or monetization
• Customers or user base
• Product adoption or usage metrics
• Deployment in production environments
• Community engagement or feedback

The project is described as a personal effort by one developer ("orange soeur") and lacks any indication of traction beyond its own development lifecycle.

Not evidenced.

There is no mention of competitors, market positioning, or competitive landscape. The description does not reference other JavaScript runtimes or platforms that wjsm might compete with or complement.

• No commercial traction: The project appears to be a solo effort without any evidence of adoption or revenue.
• Spec compliance risk: The author acknowledges the complexity of ECMAScript semantics and the difficulty of implementing them correctly, which could lead to ongoing development challenges.
• Limited team size: With only one member ("orange soeur"), there may be resource constraints for scaling or maintaining long-term development.
• Unproven market demand: There is no indication that there is a market need for this type of AOT JavaScript runtime beyond the author’s own interest.
• High technical complexity: The project involves building a full JavaScript engine, which is inherently complex and risky without external validation or user feedback.

1. What are the key challenges you've faced in achieving full ECMAScript conformance?
2. How do you plan to address performance bottlenecks in the current AOT pipeline?
3. Have you identified any specific use cases or customers who would benefit from wjsm?
4. Are there any plans for monetization or commercial partnerships?
5. What is your roadmap for improving GC performance and reducing startup times?
6. How do you intend to validate correctness beyond test262 fixtures?
7. What are the risks of relying on WASM as a target platform for JavaScript execution?