scriptc

Name: scriptc
Author: Vercel

Languages & RuntimesApache-2.0

TypeScript-to-native compiler, from Vercel Labs.

Latest v0.2.7 · Oct 9, 2026by VercelWritten in TypeScriptWebsite vercel-labs/scriptc RSS

Release activity

Release activity — 17 releases across 14 days since Sep 5, 2026. Each cell is one day; darker means more releases that day. Nothing is recorded before Sep 5, 2026. Older weeks are hidden at this screen width.
		Sep				Oct
Sunday		No releases on Sep 6, 2026	No releases on Sep 13, 2026	No releases on Sep 20, 2026	1 release on Sep 27, 2026	No releases on Oct 4, 2026
Monday		No releases on Sep 7, 2026	1 release on Sep 14, 2026	No releases on Sep 21, 2026	No releases on Sep 28, 2026	2 releases on Oct 5, 2026
Tuesday		No releases on Sep 8, 2026	No releases on Sep 15, 2026	No releases on Sep 22, 2026	No releases on Sep 29, 2026	1 release on Oct 6, 2026
Wednesday		No releases on Sep 9, 2026	1 release on Sep 16, 2026	1 release on Sep 23, 2026	1 release on Sep 30, 2026	No releases on Oct 7, 2026
Thursday		No releases on Sep 10, 2026	No releases on Sep 17, 2026	No releases on Sep 24, 2026	No releases on Oct 1, 2026	1 release on Oct 8, 2026
Friday		No releases on Sep 11, 2026	1 release on Sep 18, 2026	No releases on Sep 25, 2026	1 release on Oct 2, 2026	1 release on Oct 9, 2026
Saturday	2 releases on Sep 5, 2026	No releases on Sep 12, 2026	No releases on Sep 19, 2026	2 releases on Sep 26, 2026	1 release on Oct 3, 2026

17 releases since Sep 5, 2026, busiest day 2

Changelog

v0.2.7

LatestOct 9, 2026 · about 12 hours ago

Added 4

Supported import cycles initialize in module evaluation order, preserving shared instances, hoisted function calls, and temporal-dead-zone checks across cyclic imports.
Typed returns retain supported behavior for optional values, never-returning calls, and native collection iterators across typed function boundaries.
Standard terminal stream properties and filesystem error fields are available in supported static workflows.
An opt-in --optimization=speed mode enables runtime inlining, inline reference counting, and x86-64 runtime alignment, trading executable size and build time for runtime performance while the default release mode is preserved.

Changed 13

A small-object allocator serves strings, arrays, and records, with safe allocations and releases emitted inline.
Cycle scans back off for long-lived graphs while keeping static executables small.
Large dense arrays avoid the former sparse-storage cliff.
Direct element access and callback calls reduce boxing.
String-keyed Maps reuse cached hashes.
Optional element reads and captured parameters avoid temporary wrappers where safe.
Supported typed JSON parses directly into records.
Common number conversions use specialized paths.
Regular expressions reuse compiled patterns and subject decoding, with a native matcher for supported ASCII subjects.
Supported await-free async functions avoid fibers, and fiber switches save only required registers.
HTTP responses coalesce headers and bodies.
Console and process streams write directly to descriptors.
Native program objects use runtime ABI v8, so external object consumers must link the matching v0.2.7 runtime pack, and the versioned marker rejects incompatible runtime objects at link time.

Fixed 5

Class references retain identity through unions and collections.
Adapted callbacks remain the same function.
Record field presence stays distinct from an explicit undefined value.
Data-property writes no longer incorrectly mark unrelated class methods as replaced.
Console line buffers reserve sufficient space for long template literals and string concatenations.

From scriptc

0.2.7

Features

Supported import cycles initialize in module evaluation order. Compiled modules preserve shared instances, hoisted function calls, and temporal-dead-zone checks across cyclic imports.
Typed returns carry more native values. Optional values, never-returning calls, and native collection iterators retain their supported behavior across typed function boundaries.
Native terminal and filesystem metadata expands. Standard terminal stream properties and filesystem error fields are available in supported static workflows.
An opt-in speed mode trades executable size and build time for runtime performance. --optimization=speed enables runtime inlining, inline reference counting, and x86-64 runtime alignment while preserving the default release mode.

Performance

Native allocation and cycle collection do less work. A small-object allocator serves strings, arrays, and records; safe allocations and releases are emitted inline, and cycle scans back off for long-lived graphs while keeping static executables small.
Arrays, collections, and callbacks avoid repeated work. Large dense arrays avoid the former sparse-storage cliff, direct element access and callback calls reduce boxing, and string-keyed Maps reuse cached hashes. Optional element reads and captured parameters avoid temporary wrappers where safe.
JSON, numbers, and regular expressions use more direct native paths. Supported typed JSON parses directly into records, common number conversions use specialized paths, and regular expressions reuse compiled patterns and subject decoding with a native matcher for supported ASCII subjects.
Async execution and native I/O reduce overhead. Supported await-free async functions avoid fibers, fiber switches save only required registers, HTTP responses coalesce headers and bodies, and console and process streams write directly to descriptors.

Fixes

Class, record, and callback values preserve more JavaScript behavior. Class references retain identity through unions and collections, adapted callbacks remain the same function, and record field presence stays distinct from an explicit undefined value. Data-property writes no longer incorrectly mark unrelated class methods as replaced.
Console line buffers account for concatenated string parts. Long template literals and string concatenations reserve sufficient space before output.
Native program objects use runtime ABI v8. External object consumers must link the matching v0.2.7 runtime pack; the versioned marker rejects incompatible runtime objects at link time.

View originalPermalink

v0.2.6

Oct 8, 2026 · 1 day ago

Added 4

Native worker threads run statically compiled entry points in parallel with support for worker data, structured messages, lifecycle events, and cooperative termination
Shared buffers and integer Atomics enable worker coordination with shared views and atomic integer operations plus Int32 wait/notify
More generic class and interface patterns compile natively including concrete generic inheritance, forward references, nullable substitutions, checked class assertions, and live interface receivers
Native library calls support synchronous file reads with runtime encodings and regular-expression replacement with callbacks

Changed 3

Text, collections, and byte processing reduce repeated work through structured output, streamed split loops, keyed storage, primitive array sorting, scalar string access, and proved numeric operations
Reference handling reduces ownership work with stable loop references and synchronous callbacks that borrow safe inputs, while cycle collection adapts to mature graphs
Compilation reuses source and type information and parallelizes large native builds through source discovery, checker metadata, semantic queries, and AST traversal

Fixed 2

Deep reference chains clean up with bounded stack use by preserving ownership across generated objects and runtime containers
Generic limits and diagnostics better match the failing source with independent concrete instantiations that no longer share a global specialization cap

View originalRead the notes

v0.2.5

Oct 6, 2026 · 3 days ago

Added 1

Buffer.from accepts runtime string encodings with native string conversion that preserves encoding defaults and aliases, with catchable validation errors

Changed 4

Filesystem reads and typed-array processing do less copying by using owned storage directly and avoiding unnecessary intermediate work
Collections and object properties use storage more efficiently through improved array construction, mutation, stable sorting, string-keyed Maps and Sets, and wide object lookup
JSON, regular expressions, and string operations scan and allocate less through shared scans, batched output, and reused byte and character positions
Native values and compiler queries avoid repeated work through safe borrowing, local tagged storage, direct collection reads, reused source metadata, and batched checker requests

View originalRead the notes

v0.2.4

Oct 5, 2026 · 4 days ago

Added 1

Native Maps and Sets accept boolean, bigint, and mixed-value keys with preserved identity, insertion order, and iteration behavior

Changed 3

Numeric loops and byte access reduce runtime work through integer facts flowing through loops and typed-array access
Buffer and DataView numeric operations avoid redundant conversions and proven bounds checks
Native text, collection, and checked-value paths reduce ownership and allocation overhead through direct string storage writes and safe input borrowing

Fixed 1

Windows toolchain assets resolve through linked packages by locating installed assets from the physical package manifest path

View originalRead the notes

v0.2.3

Oct 5, 2026 · 4 days ago

Added 5

Add Node 24 filesystem support for capacity queries, link handling, timestamps, and file URL byte conversion with platform options
Add Node 24 URL handling support for authority, protocol, and mutation behavior
Add Web Streams support for writable and readable streams with controller and reader operations, tee, pipelines, and streaming encoding
Add embedded Node compatibility for CommonJS and ESM metadata, diagnostics channels, deep equality, util.types, util.styleText, text and system error utilities, MIME utilities, and no-error assertions
Allow native Set construction to accept supported collection iterators

Changed 2

Optimize compiler analysis to reuse AST child lookups, class and record metadata, graph propagation, and exception analysis instead of repeating work
Optimize native array iteration to do less work while preserving live tuple iteration behavior

Fixed 2

Preserve valid lifetimes of native values across helper and collection operations including array borrowing, map reads, string concatenation, and helper calls
Emit TypeScript runtime package sources consistently

View originalRead the notes

v0.2.2

Oct 3, 2026 · 6 days ago

Added 8

Three.js CPU workflows now compile natively and to WASI, including procedural geometry, curves, animation blending, mesh deformation, material and texture data, in-memory model loading, and CPU node graphs
Compiled libraries can send geometry, material state, and resource lifecycle notifications to an external rendering host
Stored Map and Set iterators compile statically with native cursors supporting next(), function arguments, for...of, spreads, and mapper-less Array.from while preserving live collection behavior and reference identity
Descriptor I/O and FileHandle vector and control operations compile statically, alongside scrypt, HKDF, and additional SHA-2 algorithms for native filesystem and crypto support
Node 24 URL, environment, and text utilities gain native support including URL.canParse, URL.parse, URL JSON serialization, util.parseEnv, process.loadEnvFile, TextEncoder.encodeInto, and buffer validation and transcoding
events.on adds buffered iteration, cancellation, close events, backpressure, and listener cleanup
events.once accepts EventTarget inputs and cancellation, and abort listeners support disposal
Promise timers and scheduler operations add cancellation and reference controls, with buffered interval iteration and native timer-handle lifecycle behavior

Changed 2

Compilation avoids repeated queries, scans, and allocations in frontend type queries, JavaScript binding analysis, native IR traversal, union transformations, artifact dependency collection, and serialization
Native build preparation overlaps independent work with concurrent compiler fingerprinting and native-driver discovery while preserving cache identity and invalidation behavior

Fixed 3

Static JavaScript workflows preserve more class and callable behavior including inferred class fields, inherited members, method dispatch, callable identity, collections, and async values across compiled package boundaries
Integer-boundary inference accounts for both zero signs so division and powers involving zero no longer produce unsafe integer proofs for negative-zero inputs
Embedded Node utilities preserve more input and lifecycle behavior including argument parsing, callback and promise adapters, EventEmitter once-listener reentrancy, symbol names, error-monitor ordering, and StringDecoder handling of input views and split encoding boundaries

View originalRead the notes

v0.2.1

Oct 2, 2026 · 7 days ago

Added 3

Support for more Effect 3 and Effect 4 programs to compile statically, including async and concurrent flows, services and layers, resource management, streams, schemas, and collections
Three.js CPU workloads now compile without an embedded JavaScript engine, including geometry merging, instancing, and keyframe interpolation
Typed-array constructors and prototype methods now support constructor aliases, shared backing storage, chained indexed assignments, and mutable prototype methods with receiver dispatch

Fixed 3

Native installs are smaller and more portable, with GNU/Linux compiler distributions supporting glibc 2.34 or newer and using statically linked LLVM helpers
Native values now retain identity across typed and untyped boundaries, including collections, class instances, inferred arrays, and mixed JavaScript return values
Effect platform callbacks and native streams now preserve their state with expanded lowering and promise storage layout for cycle collection

View originalRead the notes

v0.2.0

Sep 30, 2026 · 9 days ago

Added 7

scriptc ships a self-hosted native compiler bundling the native TypeScript 7 parser and checker, LLVM helper, precompiled C runtime pack, declarations, and compile-time evaluator
Standalone compiler archives are available alongside npm packages
Published Effect generators compile statically with `--npm-static=effect` for Effect.gen, Effect.succeed, Effect.log, and Effect.runPromise without an embedded JavaScript engine
Three.js CPU workloads compile natively and to WASI supporting math, scene graphs, cameras, geometry, meshes, materials, raycasting, and collision queries
WebAssembly libraries expose callable exports and host imports with WASI Preview 1 reactors supporting library profiles, synchronous host callbacks, explicit memory ownership, and independent module instances
Native FFI supports more library interfaces with static `node:ffi` bindings adding exact 64-bit and pointer ABIs, native memory views, reusable callback pools, and Darwin framework linking
Support expands for identity collections, numeric typed arrays, property descriptors, local class factories, callable properties, inherited fields and accessors, generator and async methods, and runtime-length argument spreads into supported signatures

Changed 4

The installed CLI is now a native executable with npm installing the matching platform package on supported macOS, Linux, and Windows hosts
Compilation reuses syntax metadata, property lookups, library signatures, and recursive class analysis while optional-value analysis and lowering avoid redundant traversal and copying
LLVM output shares recursive value converters with deduplicated helpers reducing generated code and work needed to produce native objects
Startup avoids unnecessary work with host libc detection cached, the JavaScript API loading TypeScript 5 only when needed, and release runtime packs omitting development debug payloads

Fixed 3

Untyped JavaScript boundaries preserve more native values including class state, shared arrays, nullable fields, constructor results, collection identity, and typed-array backing storage
Static library builds honor explicit package selections in library profile's `npm_static` list even when packages do not ship declarations
Terminal and process integration handles more native behavior with stored process streams, terminal signals, and exception handlers that resume queued work

Removed 1

Remove C emission, debugging C backend, and automatic C fallback, keeping only LLVM as the code generation backend

View originalRead the notes

v0.1.7

Sep 27, 2026 · 12 days ago

Added 5

Development builds support native source debugging with --optimization=dev adding TypeScript and JavaScript source locations across the C and LLVM backends
More Math operations compile statically including hyperbolic functions, clz32, fround, imul, expm1, and log1p
Static Promise handling supports rejection callbacks with Promise.prototype.then accepting both fulfillment and optional rejection handlers
Static compilation accepts more package layouts where installed entries can compile their own TypeScript and JavaScript imports and CommonJS packages with safe export prologues remain eligible
Dynamic globalThis exposes Node host globals by initializing the same Node globals used by embedded modules

Changed 2

Async and generator fibers commit stack memory on demand while retaining existing stack capacity and using less committed memory
Development builds compute compiler fingerprints faster with parallel fingerprint reads preserving existing cache identity and invalidation behavior

Fixed 5

Tuple spreads compile in tuple literals with const tuple inference preserved when checked with satisfies
Caught and rejected values preserve JavaScript object classification with native exception handling distinguishing objects from primitive values across catch and promise paths
TypeScript project settings and Node declarations are preserved with built-in default imports honoring effective project options
Optional chains and dynamic option records retain supported values with array callbacks inside optional chains, narrowed optional receivers, and records containing abort handles compiling correctly
Compiler analysis handles more edge cases safely where deep or shared type graphs no longer overwhelm diagnostics and property names spelled arguments are not treated as reads of the special binding

View originalRead the notes

v0.1.6

Sep 26, 2026 · 13 days ago

Added 2

Static Array behavior covers construction, mutation, indexing, flattening, splicing, and joining
Static Object and String operations expand with own-property checks, prototype tags, String.prototype.at, codePointAt, and split coercions

Changed 3

Array comparisons and string operations allocate less memory
Fibers reuse stacks and release cached memory while idle
Terminal dimensions come directly from native streams

View originalRead the notes

v0.1.5

Sep 26, 2026 · 14 days ago

Added 5

Static HTTP support for node:http adds request and response controls, timeout and event handling, connection shutdown behavior, and stricter header validation
Float64Array, indexed compound assignments, and additional analytic and remaining Math functions compile natively
Static includes, lastIndexOf, and positioned string methods accept omitted and primitive search values while preserving position coercion
Published Effect modules can compile statically through the npm-static path that follows reachable exports and prunes unused package code
Executable stripping is available as an opt-in build option

Changed 1

LLVM emits faster numeric operations with direct operations for proven integer arithmetic and numeric remainder, and avoids redundant boxing, retains, and temporary records for numeric array reads

Fixed 4

Static JavaScript coercions for string padding and search, Number conversion, and narrowed string and buffer calls now handle unions, wrappers, objects, nullish values, and omitted arguments correctly
Dynamic islands load more legacy packages including Redis 6 entry points and callable EventEmitter usage
Published LLVM helpers retain executable permissions
Switching build modes preserves reusable artifacts

View originalRead the notes

v0.1.4

Sep 23, 2026 · 16 days ago

Added 10

node:module coverage, CommonJS factory exports, and statically analyzable literal dynamic imports compile through the native module graph
Node built-in functions can be stored and passed around while preserving static calls
Overloaded callable specialization, fixed-tuple argument spreads, union receiver calls, and loose equality compile natively
One-shot and callback-based zlib codecs compile statically
fork supports parent-child messaging, execFile supports inline UTF-8 callback options, and shell output can be captured
HTTP/1.1 requests require Host by default and return Node-compatible 400 responses, with opt-out and HTTP/1.0 handling preserved; incoming chunk trailers expose raw and distinct values, while outgoing trailers support framing and streaming
Static filesystem support adds synchronous buffer overloads, async realpath, lstat metadata, readdir with Dirent, and descriptor operations
URLs add credential, origin, port, and hash behavior
Date.parse, writable process.exitCode, and scoped computed EventEmitter names compile with Node behavior
Static Set construction accepts readonly tuple seeds

Changed 1

Numeric JavaScript bitwise operators now lower to i32 operations on the LLVM backend

Fixed 5

Windows executables support GUI subsystem selection and installed CMake generators
Windows runtimes include native clock and sleep shims
GNU runtime packs preserve glibc 2.36 compatibility
Package-scoped imports use edge-specific conditions, and fallback Node declarations include RequestInfo without widening supported fetch inputs
Header and trailer parsing enforce byte and field-count limits, and trailer data is safely discarded when handlers respond before the request body finishes

View originalRead the notes

v0.1.3

Sep 18, 2026 · 21 days ago

Added 5

BigInt literals, arithmetic, comparisons, conversions, storage, byte-buffer and DataView operations, and width boundaries now compile natively while preserving Node behavior across C and LLVM backends
Static crypto utilities now include hashes, HMACs, PBKDF2, random fills and integers, timing-safe equality, and one-shot hashing through the native node:crypto surface with Node-compatible errors
Child-process stdin now supports native writes, backpressure, ending, destruction, and lifecycle and error events across C and LLVM backends
Commander 15 now compiles statically with the npm-static path preserving declaration and runtime behavior needed by Commander 15 command actions
TypeScript workspace sources now compile statically with source-only workspace package entries resolving through the program module graph while retaining existing JavaScript package boundary

Changed 1

WASI release binaries are smaller as release links strip debug sections while development output retains its metadata

Fixed 4

Generated JSON record keys are now valid with escaped and terminating property names emitting correctly in both native backends
Windows console output now preserves UTF-8 in attached consoles without changing redirected byte output
Nested recursion and discarded conditionals now lower correctly with mutual nested function references initialized before capture and discarded conditional expressions retaining lazy control flow
Library archives now retain section granularity allowing consumers to garbage-collect unreferenced archive members

View originalRead the notes

v0.1.2

Sep 16, 2026 · 23 days ago

Added 7

CommonJS module graphs compile statically with require, module.exports, exports, module metadata, caching, cycles, resolution, and failure eviction following Node semantics
Async generators support queued next/return/throw requests, promised yields, cleanup, and class, object, and private methods
for await closes custom async iterators and WHATWG readable streams correctly
Explicit resource management compiles natively with using, await using, for using, disposable Node handles, and suppressed disposal errors
import.meta.resolve, require.resolve, require.resolve.paths, and module.createRequire handle supported static requests with Node-compatible resolution and errors
Static npm declarations preserve overloads from shipped declaration files while compiling package implementations with --npm-static
Class and child handles can round-trip through unknown while private fields remain hidden

Fixed 2

Branded primitive types, leading BOM literals, TypeScript 7 project resolution, and Node type-link behavior retain their expected semantics
Dynamic any-local operators lower correctly, executable-path arguments remain intact, and URLSearchParams sorting scales without quadratic behavior