roblox-ts, a TypeScript to Luau compiler for Roblox

An AST in, Luau out

The introduction describes the project as an attempt to bridge the abilities of TypeScript to work in a Roblox environment, and the mechanism is a compiler rather than a transpiler in the loose sense, since the code is broken down into an abstract syntax tree and functionally similar structures are emitted in Luau so that the code behaves the same. That last clause is the one to hold on to. The goal is behavioural equivalence, not a textual mapping, which is why the dependency list is dominated by Roblox specific tooling rather than by a general purpose TypeScript emitter. The audience is a Roblox developer who wants the type checking, the refactoring tools and the editor support that the TypeScript ecosystem provides, while the code that actually runs in the game is Luau. The project is MIT licensed, published on npm as roblox-ts, and documented at roblox-ts.com/docs, with a Discord server for the community.

The dependencies are pinned to Roblox tooling

The package manifest is the clearest picture of how the compiler is put together, and the pinning is unusually strict. TypeScript itself is pinned with an exact version, 5.9.3, using the equals form, which matters for a compiler that walks the type checker AST. Three Roblox specific packages are pinned the same way, @roblox-ts/luau-ast at 2.1.2, @roblox-ts/path-translator at 1.1.1 and @roblox-ts/rojo-resolver at 1.3.0, and those names describe the work, parsing Luau, translating paths and resolving a Rojo project layout. The rest of the runtime dependencies are ordinary tooling, chokidar for watching files, fs-extra, kleur for terminal colours, resolve for module resolution and yargs for the command line. A compiler that depends on the Luau AST and a Rojo project resolver is a compiler that is tightly coupled to the Roblox toolchain, and that coupling is the main thing to understand before you adopt it.

The rbxtsc CLI and the build scripts

The package publishes a single binary, rbxtsc, which points at out/CLI/cli.js, and the manifest also carries a browser entry at out/CLI/browser.js for the in-browser build. The build itself is a script called tspc, so the project ships its own build tool rather than relying on tsc directly.

npm run build
npm run build-watch

The watch mode is the one that matters in practice, since it recompiles on change, and the file watcher is the chokidar dependency. A devlink script runs the build and then links the result into a devlink directory with npm link, which is how a contributor works against the local compiler rather than a published version. The lint script is eslint with the maximum warnings set to zero, and the repository carries eslint.config.ts, a prettier configuration, a .luacheckrc for the generated Luau, and several tsconfig files including a base, an eslint one and the main one. The AGENTS.md and CLAUDE.md files at the root tell you that this is a repository where automated agents are expected to work.

Testing means compiling with Rojo and running under Lune

The test script is the most instructive part of the manifest, because it shows how a compiler project proves that the code it emits actually runs. The chain is build, then compile tests, then build the test place with Rojo, then run it.

npm test

Underneath, the individual steps are visible. The compile step is jest with coverage, the Rojo step builds the tests directory into a place file, and the run step executes that place file with Lune and the Luau test harness.

npm run test-rojo
npm run test-run

There is a parallel path that runs the same place file inside Roblox itself rather than under Lune, using a run-in-roblox command with the place to load and the server script to run. Having both is the point, because a compiler for Roblox can be wrong in ways that only show up inside Roblox, and a compiler that is also used in CI needs a path that does not require Studio. The repository also carries a default.project.json and a foreman.toml, which are the Rojo project and the task runner files that tie the pieces together.

Games that ship with the compiler

The README devotes a long section to games built with roblox-ts, each with a link and a visit count, and the counts are the interesting part. BedWars is listed at 11.7 billion visits, Islands at 2.4 billion, Emergency Hamburg at 1.4 billion, Anime Card Clash at 507.6 million and SkyWars at 427.6 million, and the list continues down through games such as Jurassic Blocky, Zombie Strike, Punch Wall Simulator, All of Us Are Dead, Slither Simulator, 24 Hours Overnight, My Tycoon!, The Sewers, Deep Space Tycoon, Creepy Crawlers, Deadline, Rift Royale, Prop Hunt, Science Simulator, popper, Space War Tycoon, Unnamed Battlegrounds, Plinko Tycoon, My Crop Farm, Wealdland Foods, Vacuum Everything, LegacyVerse, Go Dig, Fashion Stars, Steal A Figure, Dungeon Life and RNG Dropper Tycoon. Whether the compiler is behind every one of those is not something the README can prove, and the section is titled Games that use roblox-ts, so treat the list as a claim by the maintainers. Either way it is evidence that the output shape is accepted by a large amount of shipped code.

A repository laid out like a compiler project

The top level listing shows the parts of a modern TypeScript compiler project. There is src/ for the implementation, tests/ for the test suite, docs/ for the documentation, include/ for the type definitions the compiler consumes, and devlink/ for the local linking workflow. The configuration files are the usual set for a project of this kind, jest.config.ts for the test runner, tsconfig.json with tsconfig-base.json and tsconfig.eslint.json, codecov.yml for coverage reporting, and foreman.toml for the task definitions. The GitHub workflows include a UnitTests badge in the README, and the repository has an .editorconfig, a .prettierignore and a .prettierrc, a .gitattributes and a .devcontainer directory for a reproducible development environment. The changelog, the contributing guide and the code of conduct style files are there as well. The overall impression is a project with a mature build and test pipeline around a compiler core.

A 3.0 release with a moving branch

The release history is short and the versions are major, which is the right shape for a compiler that changes its output. There is v2.2.0 on 2023-09-30, v2.3.0 on 2024-02-14 and v3.0.0 on 2024-09-12. Since then there have been no GitHub releases, while the last push to the default branch was on 2026-10-14, which tells you the branch is being worked on but the releases are not frequent. The repository is not archived. The practical consequence for an adopter is that a major version bump in this project is expected to change the emitted code and the configuration, and that pinning to a published version is the only way to get a reproducible build. The licence is MIT, which is the permissive grant the project uses, and the npm package is published as roblox-ts with the version field at 3.0.0, matching the newest release tag.

Editorial conclusion

roblox-ts fits a Roblox developer who wants TypeScript's type checking and editor tooling while the game still runs on Luau, and it fits a studio that wants its own build pipeline to produce the Luau output rather than hand writing it. It does not fit a project that needs every TypeScript feature, since the compiler targets a subset that Roblox's runtime can express, and it does not fit a team that wants a stable long term compiler without tracking the Roblox platform itself, since the output has to keep up with Luau and the Roblox API. Verify three things before adopting it: that the Luau output your existing project would produce still matches what Roblox Studio expects, that the pinned toolchain, TypeScript 5.9.3 and the matching @roblox-ts packages, is compatible with your own build, and that your CI can run the test path, which needs Rojo and Lune in addition to Node.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. roblox-ts/roblox-ts on GitHub