Programming Languages

Deno108.8k★

Deno is a modern JavaScript and TypeScript runtime from the original creator of Node.js. Native TypeScript support (no build step), built-in security permissions (scripts can't access your filesystem unless you say so), and a standard library that actually works. MIT, established. It can now compile desktop apps too: a webview UI plus your Deno logic in one distributable binary, an Electron alternative. Deno Deploy is their edge hosting platform. Think Vercel/Cloudflare Workers but tightly integrated with the runtime. The compatibility story has gotten much better. Deno now runs most npm packages, so the 'ecosystem gap' argument is mostly dead. You can migrate incrementally. The catch: despite being technically superior in many ways, Node.js has overwhelming market share. Your team knows Node. Your CI knows Node. Your hosting knows Node. Switching runtimes is a big decision, and 'better defaults' doesn't always win against 'everyone uses it.' Deno Deploy's free tier is limited: 100K requests/day, 1ms CPU time per request.

Bun96.5k★

Bun is a JavaScript and TypeScript toolkit in one binary: a runtime built as a drop-in replacement for Node.js, plus a package manager, test runner and bundler, and now a formatter (bun fmt) and type checker (bun check). It's free and MIT-licensed. Since December 2025 it's owned by Anthropic, which ships Claude Code on it. Install is one curl command, and you can adopt it piece by piece: run bun install or bun test inside an existing Node project without switching runtimes. Bun 1.4 (August 2026) rewrote the whole thing from Zig to Rust and added more than 1,500 tests from Node's own suite. New releases land every few weeks, and there's nothing to host. Solo through large teams: free. There's no paid tier and no Bun cloud. The cost is migration time, not money. The catch: compatibility is close, not complete. Bun's own numbers show node:http, node:fs and node:stream passing 97% of Node's tests, so test your app before moving production. The October 1.4.4 release patched three high-severity bugs, including a brotli out-of-bounds write. And one AI company now steers your runtime. Bun promises it stays MIT; Node and Deno are your hedge.

v38.1k★

V compiles to readable C and installs by cloning the repo and running make. The whole language is MIT: compiler, standard library, a built-in web framework and ORM, graphics and UI libraries, cross-compilation, hot code reloading, and a REPL. No paid tier, no enterprise build, no license that changes once you get big. Development runs on GitHub Sponsors and Patreon. The pitch is Go's simplicity at C's speed without C's memory traps. Because the primary backend emits human-readable C, builds are fast and cross-compiling is easy, and you can read what the compiler actually produced when something goes sideways. Memory management is a per-build choice: garbage collection by default, fully manual, arena allocation, or the experimental autofree. Solo: worth a weekend if you like small languages with batteries included. Small teams: good for internal tools and CLIs, not the revenue path. Large teams: Go and Rust have the libraries and the hiring pool, and Zig covers the same low-level niche with more production mileage. The catch: V is still pre-1.0, and its own feature list marks "no undefined behavior" as a work in progress.

RustPython22.5k★

RustPython is a Python interpreter rebuilt from scratch in Rust. Not bindings to CPython, a separate implementation of the language itself. That matters for two jobs: running Python inside a Rust app as a scripting layer, and running Python in the browser through WebAssembly. MIT licensed, no paid edition. There is nothing to host. You build it with Cargo, and the README admits there is no well-packaged install yet, so expect cargo install from Git plus a venv to get pip working. HTTPS and pip need the SSL feature turned on. It also compiles to a standalone WASI module, and there is a live demo running in the browser. Rust teams who want users writing plugins or config logic in Python are the real audience. GreptimeDB uses it exactly that way. Want Python in the browser for a notebook or teaching tool? Pyodide is the more mature pick, since it is actual CPython compiled to WebAssembly. Every team size pays the same, which is nothing. The catch is compatibility. The project's own disclaimer says it is not totally production-ready, and a from-scratch interpreter cannot load C extension packages like NumPy. Use it for embedding and sandboxes, not to run your Django app.

roc6.2k★

Roc is a fast, friendly, functional programming language. The pitch is that you get syntax that stays out of your way (the Elm influence is obvious) without giving up the near-native speed that usually pushes people away from functional languages. Its standout idea is a split most languages don't make: you write pure logic in Roc, and a swappable "platform" underneath supplies everything that touches the outside world, files, network, screen. That lets a web-server platform and a CLI platform each tune performance for their domain, for free, from the app author's point of view. It's open source under a permissive license. Here's the honest part, and it matters more than any feature. Roc is not ready. The team says so directly: there's no 0.1 release yet, and the current compiler, mid-rewrite into Zig, is in their own words suited for things like programming puzzles. This is pre-alpha. The credibility is real: Richard Feldman, the face of Elm, leads it, and it's backed by a nonprofit foundation with sustained, multi-year engineering behind it. But credibility is not readiness. If you write functional code and like where this is going, experiment with it, follow it, maybe contribute. The closest comparisons are Elm (same creator, same friendliness, but Roc isn't locked to the browser), Gleam, Haskell, and OCaml. Anyone choosing between them today should know Roc is the youngest and least settled of the group. The catch is simple: don't build anything you care about on Roc yet. You'd be signing up for breaking changes, a tiny platform ecosystem, and a compiler the team itself calls puzzle-grade. It's a language to watch, not to ship.

mruby5.6k★

mruby is Ruby shrunk down to fit inside other software. Instead of installing Ruby on a server, a developer compiles mruby into their own app, web server, or device so people can script it in Ruby. Matz, the creator of Ruby, leads it. MIT licensed and free. The H2O web server, ngx_mruby for Nginx, and the mitamae config tool all embed it. Nothing to host, because it is a build-time dependency. You compile it with Rake, which needs a C compiler plus Ruby 2.7 or later on the build machine, and you choose which mrbgems (its own package format) get linked in. It can also collapse into a single mruby.c and mruby.h, the way SQLite ships. Free at every team size. The real decision is Ruby versus Lua, the usual embedded scripting language. Pick mruby when the people writing the scripts already know Ruby. The catch: this is not drop-in Ruby. Standard RubyGems do not apply, strings are plain bytes with no Encoding class, and a NoMethodError often just means the gem for that feature was not linked in. A built-in regex gem only arrives in the unreleased 4.1, and it is not in the default build. Skip GitHub's auto-generated source archives too. The project says they do not build, so clone with submodules or download from mruby.org.

Zerolang5.4k★

Zerolang is Vercel Labs' experiment in a programming language that AI agents write and humans review. The program isn't really the text files. It's a compiler-owned graph of symbols, types and calls, and agents change it through checked patches (zero patch) instead of editing lines. Humans read a generated .0 text view. Apache 2.0, free. Install is a curl | bash script that pulls the compiler from GitHub releases, plus an agent skill via npx skills add. Nothing to host. The pitch is fewer wasted agent loops: stale or invalid edits fail before they touch the program, and the agent gets node IDs and graph hashes instead of guessing from source text. No paid tier, so solo devs, small teams and larger teams all pay nothing, but only people building coding agents have a reason to try it. The catch is the README's own safety warning: expect breaking changes, rough edges and security issues, and keep it away from production systems and sensitive data. It has also gone quiet. The last release shipped in June, and only a couple of commits have landed since. Study the idea, don't build on it.

CUDA Rust4.0k★

CUDA Rust is NVIDIA's official toolkit for writing GPU code in Rust, and it's free under Apache 2.0. It grew out of cuda-oxide, an NVIDIA research project, into a bigger package: shared host crates for talking to the GPU driver, plus two ways to write kernels (the small programs that run on the GPU). cuda-oxide is the hands-on option. A custom compiler backend turns plain Rust into PTX, with threads, shared memory and warp operations exposed the way CUDA C++ programmers expect. cutile-rs is the high-level option: you work on tiles of tensors, NumPy or PyTorch style, and the compiler handles scheduling. Nothing to host and no paid tier. Solo, small teams, larger teams: all free, and the bill is the GPU. You need Linux, an NVIDIA card and the CUDA toolkit. cutile-rs builds on stable Rust but wants CUDA 13.2 or newer and an Ampere or newer GPU. cuda-oxide needs a pinned nightly Rust and Clang 21. The catch: NVIDIA calls it an early-stage research project: expect bugs, incomplete features and API breakage. Keep production kernels on CUDA C++. And install cargo-oxide from NVIDIA's git repo, because the cuda-oxide name on crates.io is an unrelated 2021 crate.

flix2.8k★

Flix is a programming language that tracks side effects in the type system. Functions declare whether they do I/O, call the network or mutate state, and the compiler holds you to it. It mixes functional, imperative and logic programming, runs on the JVM, and comes out of Aarhus University under Apache 2.0. Getting started takes Java 21 or newer and the VS Code extension, which the docs call highly recommended. A command-line compiler exists too. Because it compiles for the JVM, deployment looks like any Java app. Developers curious where typed languages are heading will enjoy it, and teams experimenting with effect systems get something they can actually install. The team claims the most complete effect-oriented language available, and the feature list backs it: algebraic data types, traits, higher-kinded types, user-defined effects with handlers, structured concurrency and built-in Datalog. Need a mature JVM functional language for production today? Pick Scala. The catch is the ecosystem. Libraries, hiring and answers online are thin next to Scala or Kotlin, and at version 0.76 it is still pre-1.0, so things can change under you. Learn from it. Think hard before betting a product on it.

uiua2.2k★

Uiua is a tacit array programming language where primitives are single glyphs and data flows through a stack instead of named variables. You type ASCII, the built-in formatter rewrites it into symbols. It's in the APL and BQN lineage, MIT licensed, community-funded, and you can try it in the browser at uiua.org without installing anything. Local install is a release binary or cargo install. The real cost is conceptual: array thinking plus point-free style is a steep climb even for people arriving from other array languages. This is for programmers who find array languages beautiful, code golfers, and anyone who wants their brain bent in a productive direction. Nobody should ship production systems in it, and the project would tell you the same. BQN and J are the OSS peers; Dyalog APL is the commercial ancestor. The catch: the language is explicitly unstable, with a long history of breaking changes, and current releases are still renaming fundamental primitives. Code you write today will need rewriting. That's the price of watching a language get designed in the open.

daScript1.2k★

Daslang, formerly daScript, is a scripting language built for games that refuse to pay the usual scripting tax. The problem it targets: most embeddable languages like Lua sit behind a marshaling layer, so every call between your C++ engine and your scripts copies and converts data. Daslang is statically typed and lays out its data to match C++, which means that interop cost largely disappears. For a game pushing thousands of script calls per frame, that is the difference between scripting being viable and being a bottleneck. This is not a tool you install, it is a language you adopt. You embed the compiler into a C++ codebase, bind your native types, and wire it into your build, which is a real engineering investment. The payoff is flexibility in how you run it: an interpreter for fast iteration, ahead-of-time compilation to C++ for shipping, or an LLVM JIT, plus hot reload during development. It is backed by Gaijin Entertainment, the studio behind War Thunder, so it is proven in a shipping title rather than a side experiment. It is BSD-3 licensed and entirely free, with no commercial tier. The real comparison is to other embeddable languages, not to any paid product. Lua and LuaJIT are the defaults most teams reach for, with AngelScript, Wren, and Squirrel as alternatives. Daslang earns its place specifically when that interop overhead is hurting you and you want static typing on top. The catch is that this solves a problem most projects do not have. When Lua is fast enough, the static typing and tighter C++ integration are not worth the steeper learning curve and smaller community. Reach for it once you have measured the cost and Lua is the thing in your way.