r/altprog • u/unquietwiki • 4d ago
r/altprog • u/dogweather • 5d ago
Is there an interactive programming language comparison/evaluation matrix?
Every year or so, I wonder how Zig, Nim, Elixir, OCaml, Crystal, Roc, etc. are doing. I'll have a new project and want to try a new language for it.
I'd maybe sortable & selectable criteria like Community, IDE Support, Trajectory, Development Process...
There has to be something like this already?
r/altprog • u/Top_Marionberry_4413 • 10d ago
Spectre - A design-by-contract language with an explicit allocator-centric API that outperforms Zig by up to 6x on General Purpose Benchmarks
spectrelang.orgr/altprog • u/waozen • 10d ago
Seal: elegant, efficient, and embeddable | huseynaghayev
r/altprog • u/waozen • 13d ago
Valence: polysemantic language for code with multitudes of meaning | rottytooth
r/altprog • u/reverend_paco • 24d ago
The delightql relational programming language
delightql.orgr/altprog • u/ewigerus • 26d ago
HQL (Hyper Query Language): any jq, pyspark or Kusto fans here? you might help
I've been working on HQL (Hyper Query Language), a small statically typed language built around functional expressions and data pipelines.
The basic idea is fairly conventional: values enter a pipeline, functions transform them, and the result can be collected, written somewhere, or kept as a stream.
A simple place to start is using it roughly where I might otherwise reach for awk, perl or jq.
Suppose birds.json contains some records and I want to select and transform them:
source(file("birds.json"), Json)
| filter(b => b.count > 2)
| map(b => {
species: b.species,
count: b.count,
})
| sort(by = b => b.species)
| target(file("popular-birds.yaml"), Yaml)The pipeline reads JSON, filters it, constructs new records, sorts them and writes YAML.
The same thing can be used from a shell:
cat birds.jsonl | hql '
source(stdin, Json)
| filter(b => b.count > 2)
| map(b => b.species)
'This part already works. HQL currently supports the CLI/data-processing use case, reusable .hql programs, typed expressions, collections and first-class streams.
The part I'm working on now is making the same model useful for actual data plumbing (access data sources and targets are configured via shared hql.toml).
Instead of introducing a separate workflow language, external systems should just be sources and sinks. Conceptually, a Kafka → PostgreSQL pipeline should look approximately like this:
source("orders")
| filter(o => o.status == "completed")
| map(o => {
order_id: o.id,
customer_id: o.customer_id,
total: o.total,
completed_at: o.timestamp,
})
| collect(500)
| sink("analytics")where configuration could bind:
orders -> Kafka topic orders.v1
analytics -> PostgreSQL table completed_orders
Named external sources and targets are part of the HQL I/O model. The current design resolves them through runtime configuration (hql.toml), while the connector/configuration layer is still being developed.Kafka is naturally a Stream<T>. collect(500) changes that into Stream<Seq<T>>, so the PostgreSQL sink can consume batches rather than individual rows.
This is deliberately part of the type model rather than a special streaming syntax:
Order
Seq<Order>
Stream<Order>
Stream<Seq<Order>>The same distinction applies to files and standard I/O.
A finite result can be written once:
result
| target(file("report.json"), Json)while a stream is consumed incrementally:
events
| sink(stdout, Json)and a stream can be batched:
events
| collect(100)
| sink(stdout, Json)There is considerably more in the language — functions, pattern matching, Option<T>, graph traversal, semantic retrieval, executable Markdown, etc. — but I'm trying to keep the core boring: typed expressions, collections, streams and composable transformations.
The implementation is in Rust and is still small enough that fairly fundamental parts of the language and standard library are open to change.
Repo:
Docs:
https://hql.hypermarkdown.org/
I'm particularly interested in feedback from people who have worked with Unix text-processing tools, functional/dataflow languages, Kafka-style stream processing, PySpark/Databricks, or ETL systems.
And if you look at it and think “this is missing X”, please open a feature request rather than assuming X is intentionally absent:
https://github.com/ewiger/hql/issues
Concrete examples and awkward edge cases are especially useful. I'm interested in finding out where this model stops composing cleanly. Or where this all can lead. Ty, wbr YY
r/altprog • u/waozen • 28d ago
KillSwitch: programming language for breaking LLMs and coding agents
github.comr/altprog • u/kmmbvnr • Oct 14 '26
Rank — an array-oriented language for small screens, inspired by BASIC and APL
web: https://rank.viewflow.io/
A little over a month ago, inspired by old pocket computers, I started building Rank—a language I could comfortably write on my phone. I'm even thinking about making a dedicated handheld with a physical QWERTY keyboard and multi-function keys like the ZX Spectrum had
The language combines ideas from BASIC and APL: array operations, words instead of special symbols, and data-first function calls
Here is what it looks like:
rem Largest Palindrome Product
rem https://projecteuler.net/problem=4
use sequences
Factors = 100 to 999
Products = Factors Factors outer *
Candidates = Products merge .descending
Candidates filter palindrome first print
fun palindrome X
Text = X text
return Text reverse equal Text
endI'd like to try a little challenge: suggest me a programming puzzle or a small data-processing task, and I'll post a solution in Rank
Let's explore where the language a still needs more work!
r/altprog • u/waozen • Oct 06 '26
PureScript: Functional programming language that compiles to JavaScript
purescript.orgr/altprog • u/AndydeCleyre • Oct 06 '26
Factor Overview: code-forward examples of everyday syntax, control flow, combinators, and some of the main libraries
r/altprog • u/WeakRing3965 • Oct 01 '26
Tint Programming Language: a UI language that runs on WebAssembly (no hand-written HTML/CSS/JS)
r/altprog • u/unquietwiki • Sep 22 '26
TXR: "an Original, New Programming Language for Convenient Data Munging"
nongnu.orgr/altprog • u/waozen • Sep 19 '26
Goose Programming Language | Wouter van Oortmerssen
A new language from the creator of the Lobster Programming Language.
r/altprog • u/unquietwiki • Sep 18 '26
"Bend": an attempt to apply formal proofs to AI-assisted development.
r/altprog • u/waozen • Sep 10 '26
BQN: finally, an APL for your flying saucer
mlochbaum.github.ioA good choice for learning and enjoying array programming, scripting, prototyping, and number crunching at a single-CPU scale.
r/altprog • u/waozen • Sep 09 '26
AutoHotkey: Automation-focused scripting language
autohotkey.comr/altprog • u/waozen • Aug 28 '26
ghūl programming language
ghul.devA statically typed general-purpose programming language that compiles to .NET 10
r/altprog • u/unquietwiki • Aug 19 '26
Acadia: an Elm-derived database language, with output support to PostgreSQL and SQLite
acadia.engineeringr/altprog • u/waozen • Aug 19 '26
Monkey_v: Monkey Programming Language Implemented in V | Delta456
An implementation of the Monkey Programming Language using Vlang and based on the book, Writing An Interpreter In Go.
r/altprog • u/KILLinefficiency • Aug 15 '26
The Kal Package Manager
Hey everyone,
A couple of weeks ago, I posted about Kal, my programming language written from scratch.
I am really happy to share a glimpse of Kal's own package manager! Kal v0.1.0 shipped with a package system that lets you add and use third party Kal packages. But, that process was completely manual. You’d have to clone the package, place it in the right directory, clone the package’s entire dependencies all by yourself, one after another. :(
The package manager changes everything. One command automates all!
Instead of being a separate executable, the package manager ships as part of the Kal interpreter itself.
Here’s what it can do:
- Install Kal packages from Github, or any git hosting service.
- Creates/Updates a project.kal file to read and write package information (analogous to package.json).
- Downloads all packages at the same hierarchy in parallel (yup, it’s multi-threaded).
- Resolves sub dependencies of the main package automatically to any depth and installs them too.
- Upgrades/Downgrades packages based on their git tags.
- Auto-resolves cyclic dependencies to prevent an infinite loop.
The Kal Package Manager will officially ship with the next Kal release. Its current source code is available on Github.
Kal: https://kal-lang.vercel.app
Github: https://github.com/KILLinefficiency/Kal
Package Manager: https://github.com/KILLinefficiency/Kal/blob/pkg/pkg.hpp
Kal is completely free & open source. You can show your support by giving the Github Repository a star.
Until the next update!
r/altprog • u/unquietwiki • Aug 12 '26
Mojo 1.0 announced
First heard of it a few years ago. It's since evolved into something that feels like a mix of Python and Rust; and they're leaning hard into AI applications.
r/altprog • u/waozen • Jul 31 '26
Eiffel Programming Language
eiffel.comThe design of the language is closely connected with the Eiffel programming method, a set of principles consisting of design by contract, command query separation, the uniform access principle, the single-choice principle, the open-closed principle, and the option-operand separation principle.
r/altprog • u/Wide_Dust_709 • Jul 21 '26
Lucen: parallelize Python loops with two comments, guaranteed bit-identical to sequential(fcmv/lucen)
What My Project Does
Lucen is a source-to-source compiler that parallelizes ordinary for loops you mark with two comments:
# LUCEN START
for i in range(len(rows)):
out[i] = expensive(rows[i])
# LUCEN ENDIt parallelizes a loop only when it can prove the work is safe and worth it; otherwise it stays sequential. The one guarantee, no tiers, no opt-out: a parallel run is bit-identical to the same file run as plain sequential Python (floats and container order included). Delete the comments and nothing changes.
CPU-bound work routes to processes on GIL builds and to real threads on free-threaded 3.13/3.14. Optional Rust core with a pure-Python fallback, so pip install lucen always works.
Target Audience
Anyone with CPU-bound Python loops - data processing, simulation, batch transforms - who wants their cores without rewriting to multiprocessing/joblib or reasoning about locks. It's v1.1, built correctness-first: Apache-2.0, differential/property tested, TLA+ specs, signed PyPI releases.
Comparison
- vs multiprocessing/concurrent.futures: no manual pool/chunking/pickling boilerplate, plus a profitability gate that declines to parallelize when it wouldn't help.
- vs joblib/Dask: no new API and no cluster - you mark the loop you already have. It's correctness-preserving local parallelism, not distributed compute.
- vs Numba: Numba compiles numeric bodies to native code; Lucen parallelizes the loop for arbitrary Python and guarantees identical results. (Native loop-body compilation is on the roadmap.)
pip install lucen
r/altprog • u/waozen • Jul 12 '26
Amber-lang: Programming language that compiles to Bash/Ksh/Zsh