Programming Languages

Deno108.5k★

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.0k★

Bun is a runtime, bundler, test runner, and package manager rolled into one binary. One install, one tool. It's written in Zig and JavaScriptCore (Safari's engine) instead of V8, and the speed difference is real. Installing packages is noticeably faster than npm or pnpm. The runtime starts faster than Node. The bundler is faster than esbuild in most benchmarks. The test runner is Jest-compatible but runs parallel by default. Everything is free. No paid tier, no cloud offering. The license is technically listed as 'Other' but Bun uses MIT for the core runtime, so you can use it commercially. Solo to large teams: free across the board. Drop it into any JS/TS project. It's Node-compatible enough that most packages work without changes. The catch: 'Node-compatible' isn't 'Node-identical.' Some npm packages that depend on native Node APIs or specific V8 behaviors will break. The ecosystem is still catching up: CI environments, hosting platforms, and tooling don't always support Bun natively yet. On a team with established Node infrastructure, migration has real costs. For new projects, it's a no-brainer to try.

v37.9k★

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.4k★

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.1k★

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.

zerolang5.4k★

zerolang is an experimental programming language built for AI agents, not people. The idea: give an agent a language whose compiler speaks back in clean, structured JSON, so the agent can check syntax, trace dependencies, and get repair suggestions without parsing human-readable error spew. It comes from Vercel Labs, Apache-licensed and free. Everything about it is tuned for machines: token-efficient syntax, fast startup, low memory, zero dependencies. The compiler exposes stable inspection commands with predictable output contracts, which is exactly what an autonomous coding loop needs to work reliably instead of guessing. The catch is right there in the README: this is pre-1.0, security holes are expected, and it's explicitly not for production, sensitive data, or trusted infrastructure. It's a research bet on what agent-native tooling could look like, not something to build a product on yet. Worth watching if you work on autonomous code generation. Skip it if you need anything stable.

zero5.4k★

Zero is an experimental programming language from Vercel Labs aimed at code that AI agents need to write, check, and ship. It is a new systems language (think Rust or Go) where the compiler emits structured, machine-readable output so an agent can actually act on errors instead of pattern-matching error strings. Apache-2.0 licensed, fully free. The README is explicit that the language is not stable yet. Install drops a binary into ~/.zero/bin. No Docker, no runtime, no Postgres. zero check, zero run, zero build. Cross-compiles to common targets. Source files end in .0. Watch this if you are paying attention to where agent tooling is going. Do not build production systems on it. Rust and Go are stable, mature, and have actual ecosystems. Zero is a bet on a thesis: that languages built explicitly for AI authorship will outcompete general-purpose ones when agents do most of the writing. The catch: experimental means experimental. Vercel Labs ships interesting research, but not all of it survives. If you commit to this language now and it gets shelved in eighteen months, you own that decision.

cuda-oxide3.5k★

cuda-oxide lets you write GPU kernels in plain Rust and compiles them straight to PTX, the bytecode NVIDIA hardware actually executes. No DSL, no C++ bindings, no separate kernel language. Host and device code live in the same file and build with one command. It comes out of NVIDIA's own research lab under Apache 2.0. Nothing to host, it is a compiler backend you install and build against. The real cost is the territory: you need NVIDIA hardware, the CUDA toolkit, and tolerance for an early compiler. The pipeline runs Rust through MIR and an MLIR-style IR to LLVM and out to PTX, which is a lot of moving parts when something breaks. Rust developers doing GPU compute who would rather not drop into C++ are the audience. The device-side abstractions are ambitious: type-safe indexing, shared memory, scoped atomics, barriers, and warp and cluster operations. Everyone pays the same price, which is nothing. Happy in CUDA C already? You do not need this. The catch is that NVIDIA says it themselves. The project status section calls this alpha and tells you to expect bugs, incomplete features and API breakage. The idea is excellent and the direction matters. Do not put production kernels on it yet.

flix2.7k★

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.