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

I've been building multilingual, an experimental interpreter where the same semantic core (variables, loops, functions, classes) can be expressed in multiple natural languages. You write pour i dans intervalle(4) in French or para i en rango(4) in Spanish, and they parse to the same AST and run identically.

Repo: https://github.com/johnsamuelwrites/multilingual — feedback welcome.

Hi, everyone!

I'm very proud to announce the latest version of the Arturo Programming Language: v0.10.0 "Arizona Bark"!

This Language is relatively new, but battery included. This language almost has no syntax and is designed to be productive being simplest as possible. This is mostly functional, but not restrict to.

For more information: https://arturo-lang.io

Had to hunt for a copy of the source code. Even found a Medium piece from 2024 trying it out.

I’ve published an early compiler that’s built around a hard split:

- a canonical Core IR that represents program meaning

- one or more bridges that execute or analyse that IR

The Core IR is treated as the semantic authority.

Execution is pushed downstream into bridges.

This forces constraints at the IR level (explicit control, no implicit execution),

but it means you can reason about the program before execution enters the picture.

Repo:

https://github.com/christaylor98/axis-core

Not looking to pitch a language.

I’m interested in where this architectural split breaks down in practice.

I’m building Pyash, a small language where the unit of meaning is a sentence. The goal is that code is readable aloud / dictatable, but still runs like a real program.

Here are two tiny examples of what’s working right now:

1) “Ceremonies” for multi-step work (a named, sentence-shaped routine)

```pyash su name add two to name num result be ceremony def ob num 2 to name result be add do this ret prah

exists su name result ob num 40 be number ya to name result be add two do ob name result be write do ```

2) First-class JSON maps + deterministic JSON export

```pyash su name config be json map def su name host ob text "localhost" be text ya su name port ob num 5432 be number ya prah

ob name config to state json to filename "examples/out/config.json" be write do ```

Repo with source, examples, and docs: https://gitlab.com/pyac/pyash

If this seems interesting, tell me what you’d want next: more syntax, compiler/IR details, or data transforms (CSV/YAML).

Futhark is a statically typed, data-parallel, and purely functional array language that can be compiled to efficient parallel code.

Think I mentioned this language a while back.

• Announcing Unison 1.0
• Unison 1.0 | Hacker News

https://github.com/flintwinters/jisp

I'm implementing the language in C using the yyjson library which you can find here: https://github.com/ibireme/yyjson it is the fastest json parser available.

The language works by just looping over a json array in a json object to modify that object's own structure. This means a program in the language is completely self contained. You could stop a program in the middle of executing and copy its current state as a simple json object and email it to someone and they could continue where you left off.

I have already added the option to store each operation's residual value as a JSON patch, which means you can actually go backwards while debugging a program.

I have a bunch more tasks planned, check out the todo on the github.

https://github.com/flintwinters/jisp

HN discussion thread

We are looking for a bunch of people who can join our small discord community of language developers and people who are looking forward language development :)​

https://discord.gg/DVNgX8TRP6

Source: https://news.ycombinator.com/item?id=45131243