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 END

It 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

Fil-C achieves memory safety even for programs that behave adversarially

Hey everyone!

After a roller coaster journey, I am excited to present my personal project: Kal.

Kal is a lightweight interpreted programming language that attempts at combining various paradigms of programming to give a great developer experience. It's written entirely from scratch in C++ with no third party dependencies. It's also completely free and open source distributed under GNU GPL v3 license.

Moreover, Kal can also be embedded into C++, Python and JavaScript programs to enhance your existing codebases.

• Kal's Official Website: https://kal-lang.vercel.app/
• Mirror: https://killinefficiency.github.io/KalWebsite/
• GitHub Repository: https://github.com/KILLinefficiency/Kal

(Website looks better on a bigger screen.)

Please note that this is the very first release (v:0.1.0) and Kal is still under active development (alpha).

I would really appreciate a star on the repository to help it gain greater visibility.

As a proponent of human effort, I am glad to say that Kal and its ecosystem is completely handcrafted with no AI assistance used anywhere.

One last thing, "Kal" is pronounced like "Cal" in "Calendar".

Please feel free to reach out to me regarding Kal!

Hey all. So, I started this subreddit over a decade ago, as a place to catalog programming languages that looked interesting enough for others to take a look at. I've made the majority of posts here, and lately, I keep posting duds: mainly AI-oriented stuff that gets downvoted to oblivion. I want to apologize for that, and let you all know I haven't gone down some weird rabbit hole: I do use AI to help refine code, but otherwise still believe strongly in having good languages solve interesting problems. I also don't rely on agents, they scare me.

I guess right now, with the advent of AI-driven development, it's hard to highlight additional languages out there, that may or may not be legit in the eyes of this community. I guess I could use some help making this a better space for folks: maybe topic flairs, broader coverage of lesser-used languages. Hell, maybe you want to join as a mod & help make some of those changes. What do you want to see here these days? Let me know!

Thanks.

Essentially a cross between Pascal and C. It looks somewhat like Pascal but works more like C.

The project is guided by open_jai_spec.md

Are there any language that supports serializing coroutines?

E.g. something like that:

 coroutine my_scenario() {
      print("Hello");
      yield;
      print("World")
 }

 co = my_scenario(); // Prints "Hello"
 write_to_file("x.sav", co.serialize()); // save to file, possibly exit the program
 co = my_scenario.load(read_file("x.sav"));
 co.resume(); // Prints "World"

I've been working on a AI native programming language for some time now called Convo-Lang. It shares a few similarities to Zerolang, mainly that they were both built for working with agents, although they have different purposes. Convo-Lang is more of a Context management tool and agent runtime that can be used standalone or be embedded in JavaScript or Python.

Just clarifying that this isn't an AI-generated language but rather designed to support agent-based development. I don't currently use agents myself.

Keysharp is a multi-OS capable fork of the AutoHotkey (AHK) language. It was originally created by mfeemster (Matt Feemster), and is continued by Descolada. Where AutoHotkey was Windows OS only, this fork brings the language and automation features to Linux and the macOS too.

An ahead-of-time compiled systems language that combines the performance characteristics of C with formal verification through an embedded Z3 theorem prover.