Scriptc: compilatorul TypeScript nativ de la Vercel care nu are nevoie de Node

Daca scrii TypeScript, probabil te-ai lovit de aceeasi frustrare: codul tau ruleaza intotdeauna prin Node.js — un motor JavaScript urias, cu zeci de megaocteti de memorie si un startup lent. Ce s-ar intampla daca ai putea compila TypeScript-ul direct intr-un executabil nativ, fara niciun runtime, fara V8, fara nimic in plus?

Exact asta face Scriptc, noul compilator open source de la Vercel Labs, anuntat pe 27 iulie 2026 si devenit viral pe Hacker News in aceeasi zi. Scriptc ia codul tau TypeScript obisnuit — fara modificari, fara adnotari, fara un dialect special — si il transforma intr-un binar nativ mic si rapid. Un program care porneste in 2.4 milisecunde si ocupa 170KB. Fara Node, fara JavaScript engine in executabil.

Hai sa vedem ce face Scriptc, cum il instalezi, ce poate si ce nu poate, si daca merita atentia ta.

Ce vei gasi in acest articol:

• Ce este Scriptc si de ce e diferit de Bun, Deno sau Node
• Cum il instalezi si compilezi primul tau executabil nativ din TypeScript
• Cele trei niveluri de compilare: static, dinamic si respins — plus functia coverage
• Tabel comparativ de performanta: Scriptc vs Node vs Go vs Rust
• Cand NU trebuie sa folosesti Scriptc si care sunt limitele reale
• FAQ cu cele mai frecvente intrebari

Ce este Scriptc si de ce conteaza

Scriptc este un compilator care transforma TypeScript in executabile native. Nu este un runtime alternativ ca Bun sau Deno — nu ruleaza codul tau JavaScript, ci il compileaza in cod masina.

Diferenta esentiala: cand rulezi un program cu Node, codul tau e interpretat la fiecare executare de catre motorul V8. Cand compilezi cu Scriptc, codul tau e transformat o singura data intr-un binar care merge direct pe procesor. E aceeasi diferenta dintre a citi o reteta in fiecare seara (interpretare) si a invata-o pe de rost o data si a o sti deja (compilare).

Proiectul e open source pe GitHub la vercel-labs/scriptc si e dezvoltat de Vercel Labs — aceeasi companie din spatele Next.js, Vercel si Turborepo.

Ce tip de TypeScript compileaza?

Unul dintre cele mai importante lucruri despre Scriptc este ca nu iti cere sa schimbi nimic in cod. Nu exista un dialect special, nu exista adnotari suplimentare, nu exista restrictii de sintaxa. Tipul tau de TypeScript obisnuit — cu clase, generice, async/await, destructuring, regex, template literals — merge direct.

Scriptc foloseste compilatorul real TypeScript (tsc) pentru parsare si verificare de tipuri, apoi transforma codul intr-o reprezentare intermediara (IR), genereaza cod C, si il compileaza cu clang intr-un executabil nativ:

TypeScript → IR → C/LLVM → clang → binar nativ

Pe scurt: compilarea merge TypeScript → IR → C/LLVM → clang → binar nativ.

Ce API-uri suporta?

Scriptc acopera o parte substantiala din API-urile Node pe care le folosesti zilnic:

• Sistem de fisiere: fs (sincron si promises), path
• Proces si sistem: process, child_process, os, url
• Criptografie si retea: crypto, net, http, https, tls
• Fetch: API-ul fetch nativ, cu streams, Headers, AbortSignal
• Altele: zlib, timers, dns, dgram, readline, fs.watch

Practic, poti scrie un server HTTP complet sau un CLI tool si il poti compila intr-un binar care merge fara Node.

Cum il instalezi si primul tau binar — pas cu pas

Instalarea Scriptc e surprinzator de simpla. Ai nevoie de doua lucruri: Node.js (pentru npm) si clang (compilatorul C de la LLVM).

Pasul 1: Instaleaza Scriptc

npm install -g scriptc

Pe macOS, clang vine preinstalat cu Xcode Command Line Tools. Daca nu le ai:

xcode-select --install

Pasul 2: Scrie un program TypeScript

Creeaza un fisier simplu, de exemplu salut.ts:

function salut(nume: string): string {
  return `Salut, ${nume}! Ai compilat TypeScript nativ.`;
}

console.log(salut("Romania"));

Pasul 3: Ruleaza direct

Poti rula programul direct, fara sa compilezi manual:

scriptc run salut.ts

Pasul 4: Compileaza un binar nativ

Daca vrei un executabil propriu-zis:

scriptc build salut.ts

Asta iti creeaza un fisier executabil — pe macOS si Linux il poti rula direct cu ./salut. Un binar de ~170-200KB, care porneste in ~2.4ms.

Pasul 5: Verifica ce compileaza static

scriptc coverage salut.ts

Asta iti arata cate instructiuni din codul tau compileaza static (in cod nativ) si care sunt blocate si de ce.

Cele trei niveluri de compilare si functia coverage

Scriptc nu e un instrument „totul sau nimic”. Are trei niveluri clare de compilare si iti spune exact ce se intampla cu fiecare bucata de cod. Aceasta transparenta e una dintre cele mai bune parti ale proiectului.

Nivelul 1: Compilare statica (default)

Acesta este modul in care Scriptc functioneaza cand ii dai un fisier TypeScript. Codul tau e transformat direct in cod masina — fara motor JavaScript, fara dependinte la runtime. Ce se compileaza static ajunge in binar ca cod nativ pur.

Ce compileaza static include:

• Clase cu mostenire simpla si dispatch dinamic
• Closures cu semantica JS de capturare
• Generice (monomorphizate)
• Uniuni discriminate ca valori etichetate
• async/await pe fiberi stivuiti cu programare exacta JS
• Exceptii cu finally
• Destructuring, spread, parametri optionali/default/rest
• Getters/setters, iteratori, template literals
• RegExp (foloseste acelasi motor ECMAScript exact ca QuickJS)
• String-uri cu semantica UTF-16 exacta
• Array-uri, Map, Set cu ordine si identitate exacta JS
• JSON cu cast-uri validate la runtime
• Math, Buffer, typed arrays, ierarhii Error

Nivelul 2: Mod dinamic (--dynamic)

Cand ceva din codul tau nu poate fi compilat static, poti activa modul --dynamic:

scriptc build app.ts --dynamic

In acest mod, Scriptc incorporeaza un motor JavaScript mic — quickjs-ng, care ocupa doar ~620KB — in binar. Acest motor executa codul care nu poate fi transformat in cod nativ: dependinte npm, cod tipat any, cod care foloseste constructii dinamice nerezolvabile static.

Ce e important: orice valoare care trece din codul dinamic in cel static este validata la runtime. Daca un tip minte (de exemplu, o functie intoarce un string cand ar trebui sa intoarca un numar), Scriptc arunca un TypeError prins, in loc sa corupa memoria.

Binarul cu --dynamic are in jur de ~3MB (in loc de 170KB static), dar tot e mult mai mic decat un Node SEA (60-100MB).

Nivelul 3: Respins cu eroare precisa

Daca Scriptc nu poate compila ceva — nici static, nici cu --dynamic — primesti o eroare clara, cu un cod de eroare, un cadru de cod si de obicei un indiciu despre cum sa rescrii. Nimic nu e compilat gresit in tacere. Aceasta este o diferenta majora fata de alte instrumente care ar putea sa ignore erorile sau sa le mascheze.

Functia coverage: ce procent din codul tau compileaza

scriptc coverage este probabil functia cea mai utila pentru a-ti intelege codul. Ea analizeaza toate instructiunile si iti arata exact ce procent compileaza static:

scriptc coverage app.ts

Rezultatul arata asa:

  statements analyzed   4481
  compile statically    4451  (99%)

  blockers:
      ×2  functions with optional parameters as values   SC1090
      ×1  Promise.reject                                 SC2020

Asta iti arata ca 99% din cod compileaza static, cu doua functii care au parametri optionali folositi ca valori si o respingere de promisiune care nu pot fi compilate static.

Poti combina cu --dynamic:

scriptc coverage --dynamic app.ts

Asta iti arata exact ce ruleaza static, ce ruleaza dinamic (in motorul quickjs-ng) si ce e blocat definitiv.

Performanta: Scriptc vs Node vs Go vs Rust

Sa trecem la cifre. Scriptc se lauda cu niste numere impresionante, masurate pe Apple M-series impotriva Node, Go, Rust si Zig, cu iesire identica byte-for-byte verificata:

Sa traducem aceste cifre:

Startup de 2.4ms inseamna ca un CLI tool scris in TypeScript si compilat cu Scriptc porneste aproape instantaneu. Comparativ, Node are nevoie de ~47ms doar sa porneasca motorul V8 inainte de a executa primul rand de cod. Pentru servere care proceseaza mii de cereri, diferenta e semnificativa. Pentru CLI-uri, e o experienta diferita de utilizare.

Binar de 170-200KB inseamna ca poti distribui executabilul tau TypeScript printr-un email. Un Node Single Executable Application (SEA) are 60-100MB — Scriptc e de sute de ori mai mic. Chiar si cu --dynamic (care include motorul quickjs-ng si dependintele npm), binarul are ~3MB, tot mult sub Node.

Memorie de 1-4MB inseamna ca poti rula zeci sau sute de instante simultan pe un server mic. Node consuma 67-116MB per proces — Scriptc incape in memoria pe care Node o risipeste.

Corectitudine garantata

Scriptc ruleaza peste 800 de teste diferentiale impotriva Node. Asta inseamna ca acelasi program, rulat atat pe Node cat si compilat nativ cu Scriptc, trebuie sa produca iesire identica byte-for-byte — inclusiv formatarea numerelor (care e exacta JS, verificata fuzz pe un milion de duble).

Diferentele deliberat existente fata de Node sunt documentate si numerotate — nimic nu se abate in tacere. Serverele sunt testate cu drivere client live impotriva ambelor implementari.

Limite si cand NU trebuie sa folosesti Scriptc

Scriptc e impresionant, dar nu e un inlocuitor universal pentru Node. Trebuie sa intelegi exact unde functioneaza si unde nu, ca sa nu pierzi timp cu experimente esuate.

Cand Scriptc NU e potrivit

Proiecte cu multe dependinte npm neacoperite. Daca aplicatia ta depinde de zeci de pachete npm care folosesc cod foarte dinamic, Scriptc in modul static nu le poate compila. Modul --dynamic le poate rula, dar pierzi o parte din avantajele de performanta.

Aplicatii care necesita API-uri Node neacoperite. Scriptc acopera multe API-uri Node, dar nu pe toate. Daca folosesti API-uri mai putin comune sau pachete care depind de acestea, s-ar putea sa nu compileze.

Ecosistemul npm la momentul actual. Scriptc e tanar. Multe pachete npm nu au fost testate cu Scriptc. Daca proiectul tau e dependent de un ecosistem mare de pachete, asteapta ca suportul sa se maturizeze.

Windows ca platforma principala. Scriptc compileaza pentru Windows prin cross-compilare, dar platforma principala e macOS arm64. Daca esti pe Windows si vrei sa dezvolti direct, experienta poate fi mai putin stabila.

Cand ai nevoie de debugging Node. Daca folosesti instrumente de debugging specifice Node (inspector, profiler V8), Scriptc nu le suporta. Binarele native au propriile instrumente de debugging, dar e un alt workflow.

Cand Scriptc e ideal

• CLI-uri si tool-uri de linie de comanda — startup rapid, dimensiune mica, distributie usoara
• Servere HTTP simple — startup de 2.4ms, memorie mica, performanta buna
• Programe de procesare batch — ruleaza, executa, se opreste, fara overhead de runtime
• Distributie de programe — trimite un executabil de 170KB in loc de un intreg Node runtime
• Prototipuri rapide — scrie TypeScript, compileaza nativ, testeaza repede

Escape hatches: comptime, FFI si checked casts

Scriptc are trei mecanisme „de iesire” pentru situatii in care compilarea statica pura nu e suficienta.

comptime — cod care ruleaza la build

comptime() este o functie care ruleaza cod TypeScript la timpul de compilare (cand construiesti binarul) si incorporeaza rezultatul ca un literal in binar.

const versiune = comptime(() => {
  return JSON.parse(readFileSync("package.json", "utf8")).version;
});

Asta citeste versiunea din package.json cand compilezi si o inscrie direct in binar. La runtime, versiune e un simplu string — nu se mai citeste niciun fisier.

FFI nativ catre C

Daca ai nevoie de o functie C nativa — o biblioteca de criptografie, un driver hardware, orice — Scriptc suporta FFI (Foreign Function Interface). Declari semnatura in TypeScript si legi direct codul C:

// Declaratie
declare function fast_hash(data: Buffer): bigint;

// Legatura C directa, fara Node addon

Asta iti permite sa folosesti biblioteci C existente fara sa treci printr-un Node addon si fara V8. Limitele sunt explicite si delimitate.

Checked casts — validare la runtime

In TypeScript normal, as este o promisiune ca tu stii ce tip e o valoare. Scriptc transforma aceasta promisiune intr-o verificare concreta:

const config = JSON.parse(raw) as Config;
// In Scriptc, asta valideaza la runtime ca raw e chiar de tipul Config
// Daca nu e, arunca un TypeError prins cu mesaj clar

Daca JSON-ul nu corespunde structurii declarate, Scriptc arunca un TypeError cu un mesaj care indica exact unde e problema: expected number at $.port, got string. Nu corupe memorie, nu comportament imprevizibil — o eroare clara.

Ce aduce nou Scriptc fata de ecosistemul TypeScript

Ecosistemul TypeScript are deja cateva optiuni pentru a rula codul fara Node traditional:

Bun — un runtime JavaScript rapid, cu startup mai bun decat Node, dar tot ruleaza codul printr-un motor JavaScript. Nu compileaza in cod nativ.

Deno — un runtime alternativ la Node, cu securitate imbunatatita si suport nativ pentru TypeScript. Tot ruleaza codul intr-un motor V8, doar ca unul configurat diferit. Am scris despre Deno Desktop si cum transformi proiecte web in aplicatii desktop.

Deno Compile — permite crearea de executabile single-file, dar acestea includ intregul runtime Deno in interior. Binarele sunt mult mai mari (zeci de MB) si au acelasi overhead de pornire.

Node SEA (Single Executable Application) — permite crearea de executabile din Node, dar binarele au 60-100MB si includ tot motorul V8.

Scriptc e diferit fundamental: compileaza in cod nativ, fara motor JavaScript in binarul static. E mai aproape de experienta de a compila Go sau Rust, dar folosind TypeScript ca limbaj sursa. Daca esti interesat de Go si ce aduce nou versiunea 1.27, avem un ghid complet Go 1.27 cu noutati, exemple si migrare.

Daca te intereseaza cum alte instrumente noi schimba peisajul programarii, vezi si articolele despre modelele AI locale pentru programare — unde analizam cum poti inlocui ChatGPT cu instrumente care ruleaza pe calculatorul tau.

FAQ

Ce poti face acum

Daca esti curios, incepe simplu. Instaleaza Scriptc, ia un script mic pe care il rulezi deja cu Node si compileaza-l:

npm install -g scriptc
scriptc run scriptul-tau.ts
scriptc build scriptul-tau.ts
scriptc coverage scriptul-tau.ts

Vezi cat la suta din codul tau compileaza static, si daca ai nevoie de --dynamic. Apoi incearca sa distribui binarul — un executabil de 170KB pe care il poti trimite direct, fara sa le spui oamenilor sa instaleze Node.

Scriptc nu va inlocui Node maine. Dar arata o directie noua: un ecosistem in care TypeScript nu e doar un limbaj „interpretat”, ci un limbaj care compileaza nativ, la fel ca Go sau Rust. Si asta, pe termen lung, schimba totul.

Daca te intereseaza instrumentele noi de programare, am analizat si bug-ul Codex care umple SSD-urile cu terabytes de loguri — un exemplu de ce se intampla cand instrumentele noi nu sunt gandite pentru utilizare reala. Si daca vrei sa contribui la proiecte open-source fara sa depinzi de GitHub, vezi ghidul nostru despre Codeberg, alternativa privata la GitHub.

Scriptc este open source si dezvoltat activ de Vercel Labs. Codul sursa e disponibil pe GitHub. Acest articol prezinta informatii verificate din README-ul oficial al proiectului.

Citește și: Mojo 1.0 a ajuns — limbajul care face Python de mii de ori mai rapid — cum accelerezi codul Python fără să îl rescrii în C++. Vezi si ghidul complet Go 1.27 — noutati, performanta si cum treci la noua versiune.