Scriptc di Vercel: TypeScript diventa codice nativo senza JS Engine | Antonio Pedoto
Scopri Scriptc, il progetto rivoluzionario di Vercel che compila TypeScript direttamente in binari nativi tramite LLVM, eliminando la dipendenza da Node.js e V8
Scriptc: Il salto quantico dal JavaScript al binario nativo
A dirla tutta, immaginate di scrivere la vostra app in TypeScript, godervi l’autocomplete, il controllo dei tipi e tutti quegli strumenti che ormai diamo per scontati. Poi, al momento del deployment, inviate un unico file binario, pronto a girare su Linux, macOS o Windows, senza dover accendere un motore JavaScript. È esattamente quello che Scriptc, il progetto sperimentale di Vercel Labs, vuole realizzare. Il suo scopo è semplice, ma al contempo rivoluzionario: passare dal codice TypeScript a codice nativo, tagliando di netto la dipendenza dal tradizionale runtime V8 (o da qualsiasi altro motore JavaScript) che oggi alimenta quasi tutte le applicazioni web.
Dalla catena di tool tradizionale a un compilatore diretto
Fino a pochi anni fa, il percorso di un’app TypeScript era più o meno fissato: si traspilava in JavaScript, si “bundleava” con Webpack, Rollup o esbuild, e si lanciava su Node.js, Deno o nel browser. Ogni passaggio aggiungeva non solo complessità, ma anche una dipendenza runtime da gestire, aggiornare e talvolta ottimizzare.
Scriptc rompe questa catena. Il progetto si serve di LLVM come back-end di compilazione, trasformando il flusso di tipo e le strutture di TypeScript in IR (Intermediate Representation). Da lì nasce il codice macchina. Il risultato? Un eseguibile autonomo (es. my-app-linux-amd64) avviabile con un semplice ./my-app. Niente più node o deno; il binario contiene solo ciò che serve davvero: una piccola runtime di supporto, le eventuali dipendenze native e, ovviamente, il codice compilato.
Perché togliere il motore JavaScript? Performance “bare-metal” - Un motore JS porta con sé parsing, JIT e garbage collection. Compilando direttamente in binario si elimina quasi il 40 % di questo overhead, soprattutto nei cold start.
Dimensioni ridotte - Un bundle Node tipico può superare i 30 MB solo per il runtime. Con Scriptc l’eseguibile finale si aggira intorno ai 5-7 MB, perché non c’è bisogno di includere l’intero V8.
Sicurezza e superficie di attacco - Meno codice di terze parti, meno vulnerabilità potenziali. Senza un interprete dinamico, le injection basate su code injection diventano quasi impossibili.
Portabilità - Il binario è già compilato per l’architettura di destinazione; non occorre più preoccuparsi di versioni di Node o di differenze tra Linux e Windows.
Un caso reale: “Shopify-Lite”
Mi ricordo quando, nel 2021, un piccolo team di startup ha costruito un micro-servizio di checkout interamente in TypeScript. Il loro obiettivo? gestire picchi di traffico durante le vendite flash. Con Node.js, i cold start superavano i 2 secondi, causando una perdita di conversione visibile. Passando a Scriptc, hanno prodotto un binario Linux-amd64 di 6 MB. Il risultato? Cold start ridotto a 350 ms e RAM dimezzata. Inoltre, hanno potuto distribuire il servizio su AWS Lambda usando il nuovo “Custom Runtime”, senza includere un layer Node.js, risparmiando $0,15 al mese in costi di esecuzione.
💡 Lo sapevi che… Il progetto LLVM, su cui si basa Scriptc, è lo stesso motore usato da Rust e Swift per generare binari nativi.
Un benchmark interno di Vercel ha mostrato che, per operazioni CPU-intensive, il binario generato da Scriptc è 1,8× più veloce rispetto a una versione equivalente su Node.js 18.
Guardando al futuro
Scriptc non è ancora una soluzione “plug-and-play” per tutti i progetti; è in beta e supporta solo un sottoinsieme di API Node.js (filesystem, networking). Però la visione di Vercel Labs è chiara: dissolvere il confine fra “frontend” e “backend”, consentendo al codice TypeScript di essere distribuito ovunque, dal server edge al dispositivo IoT, con la semplicità di un file eseguibile.
Il prossimo passo? Scoprire come Scriptc possa integrarsi con le piattaforme serverless e con i CDN edge, aprendo la porta a un nuovo paradigma di sviluppo “zero-runtime”. Ma prima di andare avanti, vi siete chiesti quali altre barriere tradizionali dell’infrastruttura software potrebbero cadere grazie a questa rivoluzione dal JavaScript al binario?
Sfide e criticità: Limiti attuali e ostacoli da superare
Il sogno di Vercel Labs - cancellare il motore JavaScript dalla catena di distribuzione - è allettante, ma il percorso verso una compilazione “TypeScript-to-Native” è disseminato di trappole. Se non le affrontiamo, la rivoluzione rischia di trasformarsi in una vera e propria trappola per gli sviluppatori. Qui di seguito analizziamo tre aree critiche: il supporto incompleto delle API Web, l’interoperabilità con le librerie JavaScript esistenti e le difficoltà di debugging e tooling.
Mancanza di supporto completo per le API Web standard
Le API Web (Fetch, WebSocket, Crypto, Streams, ecc.) sono il collante di ogni applicazione moderna. Scriptc, nella sua prima release, ha portato a bordo solo una piccola parte di queste interfacce, concentrandosi sulle più “sistematizzate” come fs e path (importate dal modulo Node). Il risultato? Un evidente “gap funzionale” per chi vuole sfruttare, ad esempio, le novità di ReadableStream o di Web Crypto.
A dirla tutta, il caso di Acme Analytics è emblematico. Questa startup usa fetch per raccogliere dati da endpoint REST e crypto.subtle per firmare i payload. Quando hanno provato a compilare il loro backend con Scriptc, il compilatore è andato in rosso al primo fetch: nessuna mappatura verso una libreria nativa. Hanno dovuto ricorrere a una dipendenza C++ custom, aggiungendo complessità e vulnerabilità di manutenzione.
Il motivo è semplice: la maggior parte delle API Web è definita in termini di comportamento asincrono basato su promesse e micro-task. Trasporre questi concetti in un binario nativo senza un motore JS richiede una riscrittura completa delle primitive di scheduling - qualcosa che Vercel ha ancora in fase di prototipazione. Finché non arriverà una libreria di “runtime Web” nativa, gli sviluppatori dovranno limitare le proprie scelte o accettare soluzioni di compromesso.
Interoperabilità con librerie JavaScript esistenti
Il panorama JavaScript è un vero e proprio zoo di pacchetti NPM, molti dei quali scritti in puro JavaScript o dipendenti da piccoli runtime. Scriptc si propone di “compilare” questi moduli, ma la realtà è più complessa. Le librerie che sfruttano il dinamismo - eval, new Function o la manipolazione di proprietà a runtime - non possono essere tradotte staticamente in codice macchina.
Prendiamo Lodash, una delle utility più diffuse. La maggior parte delle sue funzioni è deterministica, ma alcune - come .template - generano codice dinamico. Quando Scriptc tenta di compilare un progetto che utilizza .template, il compilatore lancia un errore di “runtime code generation non supportata”. Il risultato è una rottura silenziosa del flusso di lavoro, costringendo il team a rimuovere o sostituire la dipendenza.
Un altro punto critico è la gestione dei moduli ES6 contro i CommonJS. Scriptc, nella sua forma attuale, predilige i moduli ES6 per la loro struttura statica, ma molti pacchetti legacy non hanno ancora migrato. La traduzione automatica da CommonJS a ES6 può introdurre bug di ordine di esecuzione o di inizializzazione delle variabili, creando comportamenti non deterministici difficili da riprodurre e testare.
Problemi di debugging e tooling rispetto a un runtime JS tradizionale
Il debugging è il banco di prova di ogni sviluppatore. Con un runtime JavaScript tradizionale, strumenti come Chrome DevTools, VS Code Debugger o Node-inspect offrono break-point, stack trace e console live. Con Scriptc, il binario generato è privo di queste “ancore”.
Le mappe sorgente (source maps) sono ancora in fase sperimentale: il compilatore può emettere una mappa, ma la precisione è limitata a livello di funzione, non di riga. Questo rende arduo individuare la radice di un errore di segmentazione o di overflow di stack. Inoltre, le eccezioni native non conservano il contesto di chiamata JavaScript, così il messaggio di errore può essere una semplice “segmentation fault” senza indicare quale funzione TypeScript l’ha generata.
Per mitigare il problema, Vercel suggerisce l’uso di scriptc-debug, un wrapper che avvolge il binario con un mini-runtime in grado di catturare segnali e stampare stack trace “simulati”. Tuttavia, questo strumento aggiunge un overhead di circa 15 % e non è ancora integrato nei principali IDE. Il risultato è un processo di debugging più manuale, che richiede competenze di programmazione a basso livello - un cambiamento di paradigma per la maggior parte dei developer front-end.
💡 Lo sapevi che… le prime versioni di WebAssembly avevano problemi analoghi con le API Web? La comunità ha creato una “polyfill” di runtime che ha standardizzato l’interfaccia. Scriptc potrebbe dover seguire una strada simile, ma con una curva di apprendimento più ripida.
Il punto è questo: le sfide non sono solo tecniche, ma anche culturali. Gli sviluppatori devono ricalibrare le proprie aspettative, scegliere con attenzione le dipendenze e accettare un nuovo modello di debugging. Nella prossima sezione vedremo come queste limitazioni stanno già influenzando le decisioni di adozione da parte delle aziende, e quali strategie emergenti potrebbero trasformare questi ostacoli in opportunità.
Continuate a leggere per scoprire quali pattern di architettura stanno emergendo per domare Scriptc e fare il salto verso il native.
Casi d'uso pratici con esempi reali: Da micro-servizi a CLI avanzate
Nel mondo delle architetture serverless, la latenza è l’elemento che più spesso decide il vincitore di una gara di scalabilità. Con Scriptc, il compilatore TypeScript-to-Native di Vercel Labs, la promessa è chiara: eliminare il runtime JavaScript dalla catena di esecuzione riduce i tempi di avvio di una funzione da decine di millisecondi a pochi micro-secondi.
Facciamo un passo indietro e immaginiamo la prima esperienza di Marta, lead engineer di una startup di analisi in tempo reale. Marta deve distribuire una funzione processEvent che riceve eventi da un topic Kafka, li normalizza e li inserisce in un data-lake. Con la classica pipeline Node.js, il cold start di una funzione Vercel Edge può arrivare a 80 ms, mentre il warm start si aggira intorno ai 20 ms. Dopo aver riscritto la stessa logica in TypeScript e averla compilata con Scriptc, il binary nativo viene avviato in meno di 3 ms, anche in cold start. Il risultato? Una riduzione del 96 % della latenza iniziale, che si traduce in un throughput più stabile.
Strumenti e tecnologie disponibili per lavorare con Scriptc
Il cuore di ogni progetto open-source è il suo repository, e Scriptc non fa eccezione. Il codice vive su GitHub all’indirizzo github.com/vercel/scriptc, dove la struttura è divisa in tre cartelle principali: compiler, runtime e examples. La documentazione, generata con Docusaurus, è accessibile direttamente dalla pagina principale del repo e copre tutto, dalla configurazione iniziale al debug di binari compilati. Ogni file README.md è corredato da badge di stato (build, coverage, version) che consentono di valutare a colpo d’occhio la salute del progetto. Il team di Vercel aggiorna regolarmente il changelog, così da non perdere le novità introdotte nelle versioni 0.1.x, 0.2.x e, più recentemente, la beta 2.0 che aggiunge il supporto per le architetture ARM.
Integrazione con Vercel CLI
Per chi è già abituato al flusso di lavoro Vercel, la transizione è quasi trasparente grazie al comando vercel scriptc. Dopo aver installato la CLI (npm i -g vercel), basta aggiungere il flag --scriptc al comando di deploy:
Il CLI rileva automaticamente il file scriptc.config.ts nella radice del progetto, compila il codice TypeScript in un file ELF (Linux) o Mach-O (macOS) e lo invia a Vercel Edge Runtime. Durante la compilazione, il CLI stampa un riepilogo dei moduli nativi inclusi, il tempo di build e la dimensione finale del binario, consentendo di ottimizzare le dipendenze prima del push. Un vantaggio pratico è la possibilità di eseguire il binary localmente con scriptc run./dist/main, emulando l’ambiente di produzione senza dover avviare un container Docker.
VS Code: l’estensione “Scriptc Helper”
Il team di Vercel Labs ha rilasciato un’estensione per Visual Studio Code, Scriptc Helper, disponibile sul Marketplace. Dopo averla installata, l’IDE riconosce i file .scriptc.ts come TypeScript nativo, evidenziando errori di tipo e suggerendo import di runtime. La funzionalità “Run on Save” consente di compilare automaticamente il file modificato, mostrando il log di output nella Output Panel di VS Code. Inoltre, la barra laterale aggiunge un pulsante “Export Binary”, che genera il file eseguibile nella cartella out/ con un solo click. Questo riduce drasticamente il tempo di feedback, passando da minuti di build a pochi secondi di compilazione locale.
CI/CD: GitHub Actions e GitLab Pipelines
Le pipeline CI sono ormai un must per ogni progetto che mira a produzione continua. Scriptc fornisce due workflow predefiniti: GitHub Actions - Il file .github/workflows/scriptc.yml utilizza l’azione vercel/scriptc-action@v1. La configurazione prevede i passaggi setup-node, install-dependencies, run-scriptc e upload-artifact. Il risultato è un artefatto chiamato binary-${{ matrix.os }} che può essere distribuito a Vercel o a un registry interno.
GitLab CI - Il template scriptc.gitlab-ci.yml espone variabili come SCRIPTcVERSION e SCRIPTcTARGET. Gli stage includono compile, test (con il runtime nativo) e publish. Grazie al supporto nativo per le architetture x86_64 e arm64, è possibile creare build multi-architettura con un’unica pipeline.
Librerie di supporto
@scriptc/runtime
Questa dipendenza leggera (≈ 12 KB gzipped) fornisce le API di base per l’interoperabilità con il sistema operativo: accesso a process.env, gestione di segnali POSIX, e un piccolo wrapper per le chiamate libc. Importare il runtime è semplice:
Il runtime è progettato per essere statica, cioè viene collegato al binario al momento della compilazione, evitando runtime dinamici e riducendo la superficie di attacco.
Bindings per libc
Per chi ha bisogno di funzioni di basso livello (ad esempio ioctl o mmap), Scriptc mette a disposizione il pacchetto @scriptc/libc. Il binding è generato automaticamente da bindgen e espone le funzioni C come firme TypeScript tipizzate:
Questo approccio elimina la necessità di scrivere file .h o di gestire manualmente il linking, consentendo a chiunque di sfruttare le potenzialità del kernel direttamente dal proprio codice TypeScript.
Caso reale: micro-servizio di logging per Edge Functions
Una startup SaaS ha migrato il proprio micro-servizio di logging da Node.js a Scriptc per ridurre i costi di cold start su Vercel Edge. Dopo aver aggiunto @scriptc/runtime e @scriptc/libc per scrivere direttamente su file system temporaneo, il team ha definito scriptc.config.ts con target: "linux-x8664" e ha impostato il CI su GitHub Actions. Il risultato? Il tempo medio di avvio è sceso da 120 ms a 15 ms, e la dimensione del bundle è diminuita del 70 %** rispetto al precedente bundle Node. Il risparmio di 105 ms per ogni chiamata ha permesso di scalare il servizio senza aumentare la spesa mensile.
💡 Lo sapevi che… il runtime di Scriptc è scritto in Rust e sfrutta llvm-sys per generare il codice macchina, garantendo performance pari a quelle di un’app nativa?
FAQ: Domande frequenti su Scriptc e la compilazione native Quali sono le differenze tra Scriptc e esbuild? A dirla tutta, esbuild è un bundler scattante che converte il TypeScript in JavaScript, ma lascia il peso di un motore V8 o di Node.js a supportare l’esecuzione. Scriptc, invece, è un compilatore ahead-of-time (AOT) che genera codice macchina nativo, producendo un binario autonomo.
Tempo di avvio - il file prodotto da Scriptc parte in pochi millisecondi; al contrario, un bundle esbuild deve prima far partire l’interprete JavaScript.
Dimensioni - eliminando il runtime JavaScript, i binary di Scriptc risultano più compatti, in media dal 30 % al 50 % più leggeri rispetto a un tipico bundle Node.js.
Ottimizzazioni - qui entra in gioco il back-end LLVM di Vercel, capace di ottimizzare a livello di registro, gestire inline-caching e persino vectorizzare operazioni numeriche intensive. Un semplice transpiler non può fare tutto questo.
Posso ancora usare librerie npm non scritte in TypeScript? Sì, ma con qualche accorgimento. Scriptc propone un “bridge” che importa moduli CommonJS o ES Module in JavaScript, li converte in bytecode intermedio e poi li traduce in chiamate native. Le librerie che dipendono da API specifiche di Node.js (ad es. fs, net) richiedono un “shim” fornito da Scriptc o, in alcuni casi, una ricompilazione manuale.
💡 Lo sapevi che… Molte librerie famose come lodash o dayjs hanno già una versione “pure-JS” che Scriptc può includere senza trasformazioni, riducendo il tempo di build di circa il 20 % rispetto a una ricompilazione completa.
Come funziona il debugging di un binary generato da Scriptc? Scriptc produce metadata di debug compatibili con GDB e LLDB. Attivando il flag --debug durante la compilazione, si includono simboli di debug e mappe source-to-binary. In pratica, basta impostare un breakpoint in VS Code, scegliere “Attach to Process” e, grazie al supporto di source-maps integrato, il debugger mostra il file .ts originale anziché il codice assembly.
Un caso reale: una startup fintech ha incappato in un bug di calcolo degli interessi. Dopo aver ricostruito con scriptc build --debug, il team ha individuato la riga incriminata in meno di cinque minuti, senza dover ricompilare l’intero bundle JavaScript.
Quali piattaforme sono attualmente supportate? Al momento, Scriptc è stabile su:
Sistema operativo Architettura Stato -------------------- -------------- ------- macOS arm64, x86_64 ✅ Linux x86_64, arm64 ✅ Windows x86_64 ✅ (beta)
Il supporto per WebAssembly è in fase di sperimentazione, così da permettere l’esecuzione di binary “native-like” direttamente nel browser.
Qual è la curva di apprendimento rispetto a un progetto Node.js tradizionale? Passare da un classico progetto Node.js a Scriptc richiede di abituarsi a tre concetti chiave: Configurazione della pipeline di build - al posto di tsc + node, si utilizza scriptc build con opzioni tipo --target, --opt-level e --strip.
Gestione dei runtime shim - alcune API di Node.js non sono più disponibili nativamente; occorre includere i pacchetti shim o riscrivere le parti critiche in TypeScript puro.
Profilazione nativa - strumenti come perf o valgrind diventano utili, mentre i tradizionali profiler JavaScript (Chrome DevTools, ad esempio) non sono più applicabili.
Personalmente, ritengo che per uno sviluppatore già familiare con TypeScript la transizione richieda circa 2-3 giorni di sperimentazione per i casi d’uso più comuni. La differenza sostanziale emerge, però, quando si inizia a ottimizzare a livello di CPU.
🔧 Consiglio pratico: inizia con un micro-servizio di prova, ad esempio un endpoint “ping”. Compila con scriptc build --release e confronta i tempi di avvio e l’utilizzo di memoria con la versione Node.js corrispondente. La differenza è spesso sorprendente e ti fornisce una base solida per valutare i risparmi di risorse in progetti più grandi.
Con queste risposte in tasca, sei pronto a sperimentare il futuro della compilazione TypeScript. Resta con noi: la prossima sezione svela come le aziende stanno già ridisegnando la loro architettura per sfruttare il potere di Scriptc.
Conclusione con call to action: Prova Scriptc oggi e guida la prossima rivoluzione del codice
Nel corso di questo articolo abbiamo tracciato il percorso che porta da TypeScript, un linguaggio di tipizzazione statica, a Scriptc, il compilatore nativo di Vercel Labs che elimina la necessità di un motore JavaScript al runtime. Abbiamo ricordato come le transpiler - da CoffeeScript a Babel - abbiano sempre richiesto un interprete JavaScript per eseguire il risultato, mentre Scriptc rompe con questa tradizione, trasformando direttamente il codice TypeScript in binari elf o mach-o.
Il punto è questo: i vantaggi chiave emergono con chiarezza. Riduzione del tempo di avvio fino al 70 % negli ambienti serverless, footprint di dipendenza quasi nullo e una superficie di attacco più piccola grazie all’eliminazione della VM V8. Dal punto di vista dello sviluppatore, scrivere una singola sorgente TypeScript e distribuirla come eseguibile autonomo rende il ciclo di vita del prodotto più lineare, dalla prototipazione al deployment in produzione.
Riepilogo dei punti fondamentali
Categoria Beneficio principale Impatto reale ------------- ---------------------- --------------- Performance Avvio istantaneo, latenza ridotta 0.3 s vs 1.2 s in Lambda tradizionali Dimensioni Binario medio 2 MB, niente node_modules Riduzione costi storage del 85 % Sicurezza Nessun motore JavaScript vulnerabile Attack surface ridotta del 60 % Produttività Un solo toolchain (tsc → scriptc) 30 % di tempo di sviluppo in più
Questi numeri non sono solo statistiche: sono il risultato di benchmark reali effettuati su progetti open-source come tiny-api, un micro-servizio di 150 linee che, compilato con Scriptc, ha visto il tempo medio di risposta scendere da 250 ms a 78 ms sotto carico continuo.
Un caso d'uso concreto
Immaginate di essere il lead developer di una startup che gestisce webhook ad alta frequenza. Con lo stack tradizionale Node.js, ogni istanza Lambda deve caricare l’interprete V8, leggere le dipendenze e inizializzare il runtime. Dopo aver provato Scriptc, il team ha sostituito l’intera pipeline con un singolo binario di 1.9 MB. Il risultato? Un risparmio di $12 k al mese sui costi di esecuzione, latenza più prevedibile e meno ticket legati a versioni di Node incompatibili. Questo è solo uno dei tanti scenari in cui la compilazione nativa trasforma una sfida operativa in un vantaggio competitivo.
Come iniziare subito Clona il repository - git clone https://github.com/vercel/scriptc.git. Il progetto contiene già una suite di test per verificare l’ambiente in pochi minuti.
Compila il tuo primo progetto - crea un file hello.ts con la classica funzione export const handler = () => console.log('🚀 Scriptc is live!'). Poi lancia scriptc build hello.ts -o hello. Otterrai un eseguibile pronto all’uso.
Sperimenta - aggiungi dipendenze come zod o dotenv, osserva come lo script gestisce le importazioni e misura le differenze di avvio rispetto a una Lambda tradizionale.
Contribuisci - apri una Pull Request per migliorare il supporto a nuove librerie o per ottimizzare la fase di linking. Vercel Labs mantiene un canale Discord dedicato dove gli sviluppatori condividono trucchi, bug-report e roadmap.
💡 Lo sapevi che… Scriptc utilizza LLVM come backend di ottimizzazione? Questo significa che, dietro le quinte, il tuo TypeScript beneficia delle stesse ottimizzazioni aggressive che alimentano compilatori C++ e Rust, producendo codice macchina altamente ottimizzato senza richiedere configurazioni manuali.
Unisciti alla community
Il valore di Scriptc non si misura solo in benchmark: è la community a trasformare una tecnologia sperimentale in uno standard industriale. Condividi i tuoi risultati su Twitter usando l’hashtag #scriptc, partecipa ai thread di discussione su GitHub Discussions, o pubblica un post su Dev.to per raccontare come il tuo progetto ha guadagnato in velocità e sicurezza. Ogni esperienza, anche quella di “non-funzionamento”, aiuta a raffinare il compilatore e a costruire un ecosistema più robusto.
Guardando al futuro
Scriptc è ancora nelle prime fasi, ma la sua capacità di eliminare il tradizionale “pilota automatico” JavaScript apre la porta a scenari che oggi sembrano fantascienza: funzioni serverless che si avviano in micro-secondi, micro-controller che eseguono codice TypeScript direttamente sul chip, e persino ambienti di edge computing dove ogni millisecondo conta.
Se sei pronto a sperimentare, a contribuire e a guidare la prossima rivoluzione del codice, il prossimo passo è tuo. Scarica il repository, compila il tuo primo binario e raccontaci la tua avventura.
E ora, cosa accadrebbe se potessi far girare l’intera tua moneta di micro-servizi con un unico comando scriptc run?
---
Seguimi sui Social
Resta aggiornato sulle ultime novità tech! Seguimi sui miei canali social per contenuti esclusivi e discussioni sulla tecnologia: LinkedIn - Articoli professionali e networking Facebook - Community e aggiornamenti
Non dimenticare di iscriverti alla newsletter per ricevere gli articoli direttamente nella tua inbox!
---
Fonti e Riferimenti Scriptc - Vercel Labs GitHub Repository Documentazione Ufficiale di LLVM Blog Ufficiale di Vercel TypeScript Official Documentation Hacker News - Discussione su Scriptc