langs-in-rust: a hand-curated table of Rust-written languages

A directory that ships a generator, not a library

The repository description is blunt about the intent: a list of programming languages implemented in Rust, for inspiration. The README says the list is probably incomplete and is meant as a source of inspiration and comparison, plus a directory of interesting projects in this vein. What sits in the tree is small and deliberate: README.md, a Cargo.toml, Cargo.lock, a languages.json data file, and src/ and tests/ directories. The Cargo package is named langs-in-rust at version 0.1.0, with the description "Update the list of languages written in Rust" and, decisively, publish = false. So there is no crate to install from a registry and no library API to call. The value is the table and the data file behind it, and the program is a maintenance tool for whoever keeps that table current.

The inclusion test is two questions, and they are loose

The README states the criteria in full, and they amount to: is it a language, and is it written in Rust. That is the whole editorial policy, and its looseness shapes the table. The list opens with Deno, Rust itself, Bun, Sway, Typst, nu and swc, so runtimes, toolchains and the Rust compiler itself all sit alongside what most people would call languages. Further down are Boa's embeddable JavaScript engine, Winglang, Leo, Roc, Melody, Rhai, Gluon, Scryer Prolog, Starlark, Steel, RayQL and a long tail of smaller projects with a few dozen entries each. Some entries carry notes that matter. Tvix is described as a read-only mirror of another tree, so it is a pointer rather than a maintained copy, and several entries describe themselves as experimental, in progress or toy, Wright among them.

The status column is uniform, so it carries no information

The table has four columns: name, stars, status and description. The status column is the part worth distrusting. Every row visible in the listing reads Active, from Deno at the top down to the smallest projects, which means the field records the author's intent for the list rather than a verified state of each project. A reader looking for a signal about whether a given project is still alive will find nothing in that column. The star column has the opposite problem: it looks quantitative but is a snapshot of a popularity metric attached to a moving target, and the stated intent is inspiration rather than ranking. Neither column supports a decision on its own. The description column, which is usually a phrase borrowed from each project's own tagline, is the most informative part of the row, and the one most likely to need checking at the source.

The generator behind the table: JSON, an HTTP client and a date stamp

The dependency list in Cargo.toml explains what the maintenance program does. It pulls in serde with the derive feature and serde_json for the data shape, chrono with std, clock and serde for timestamps, dotenvy for reading environment files, and ureq version 3 with the json and platform-verifier features as the HTTP client. The presence of a JSON HTTP client and a serde-based data file, next to a languages.json at the repository root, is consistent with a program that fetches metadata from a forge API and writes the list into that file. The README.md then carries the rendered table for humans, and tests/ holds the checks. Nothing in the tree indicates a published binary, a CLI flag set or a documented invocation, so the program is a maintainer's tool. The Cargo.lock is committed, which pins the dependency graph for whoever runs it.

Getting hold of it: a clone, not an install

There is no install step to copy, and that is a property of the project rather than an omission. The package sets publish = false, so it is not distributed through the Rust registry, and the repository publishes no GitHub releases, so there is no tagged binary to download either. A reader who wants the data takes it from the repository itself: README.md for the human-readable table, languages.json for the same content in machine-readable form. Someone who wants to run the updater clones the repository and builds it with the standard Cargo workflow, and the crate's own manifest is the only configuration in play:

[package]
name = "langs-in-rust"
version = "0.1.0"
edition = "2021"
description = "Update the list of languages written in Rust"
readme = "README.md"
publish = false

The manifest also lists the dependencies that matter for a run: a JSON HTTP client and a serializer. The dotenvy entry implies configuration arrives through environment variables from a local .env file rather than command-line arguments, so expect to supply credentials or a token for the API it queries before the program does anything useful.

Where a curated list loses to doing the query yourself

The alternative approach is the one the tool already automates: ask the forge directly for repositories in a language topic, then filter by implementation language yourself. The difference in approach is that a curated table applies a human judgment about what counts as a language, so it includes the Rust compiler itself, Deno, Bun and swc, and it excludes nothing on the grounds of being a tool rather than a language. A topic query inverts the problem. It returns whatever is tagged, including projects that are libraries rather than languages, and it gives you no indication of whether a project is finished. The curated table is better for discovery because it is opinionated and short. It is worse for completeness because it is a snapshot that only the maintainer can extend, and the README says as much when it calls itself probably incomplete.

Editorial conclusion

Use langs-in-rust when you want a fast survey of which languages exist as Rust implementations and a pointer to each project's own repository, and read the table as a directory rather than a ranking. Do not depend on the crate itself: the package version is 0.1.0, publish is set to false in Cargo.toml, and the repository ships no releases. Before you act on any row, verify the project's own repository and the licence, which GitHub lists as unknown for this repository, rather than the star count in the table.

Frequently asked questions

Official sources

1. alilleybrinker/langs-in-rust on GitHub
2. Issues
3. README