r/AIprogrammingLanguage • • Sep 21 '26

MadC C/C++ Compiler v0.100.0 — the Nexus

9 Upvotes

v0.100.0 — the Nexus: a multi-client IDE, an agent-addressable IR, and measured C++11 conformance at 75.1%

With version 0.100.0 of the madc compiler, based on the gcc torture test suites we currently score:

  • C at 99.2% of the in-scope gcc c-torture set under --std=c17

  • C++98 80.0%

  • C++11 75.1%

  • C++14 49.4%

  • C++17 41.6%

  • C++20 53.0%

Why a new C/C++ compiler when GCC and CLANG rule the roost? Well, MadC isn't just an AOT C/C++ compiler. It's primarily a JIT compiler. You can run C/C++ code as shebang scripts without requiring system headers installed, because they are precompiled into the compiler (relax... it can still include them externally if you want/need to). You can also embed madc as a JIT scripting language into your own programs.

What's this "nexus" stuff about? Well, there's also an IDE that has the compiler built in, and the same binary can operate in headless, CLI, ed/ex line mode, TUI and GUI mode under Linux, MacOS and Windows. With multi-client -> server connections with MCP and LSP servers. Oh, and a VS Code plugin to boot.

Why? Why not? It was primarily an exercise in developing madc's multi-mode UI module.

Oh, I should also mention that in addition to supporting standard C and C++, it also supports the "MadC language" dialect which brings in a load of conveniences to make C and C++ easier to use, including such things as:

  • automatic includes (no need to use #include <iostream>)

  • automatic namespace resolution (with controllable precedence order)

  • "script mode" (automatic main() function wrapping)

  • defer, :=, go, yield, await, untyped variables

  • well over 100 convenience functions from other languages

  • Uniform Function Call Syntax (UFCS)

  • URI Channels: file:// pipe:// tcp:// udp:// uds:// exec://

  • ... and much more


r/AIprogrammingLanguage • • Jul 30 '26

👋 Welcome to r/AIprogrammingLanguage - Introduce Yourself and Read First!

9 Upvotes

Hey everyone! I'm u/kindredseer, a founding moderator of r/AIprogrammingLanguage.

This is our new home for all things related to designing and implementing programming languages with assistance from AI. We're excited to have you join us!

Projects with any level of LLM involvement are welcome here. That may mean occasional help with an algorithm, documentation, testing, or debugging; regular use of AI coding tools; or extensive collaboration with an LLM throughout the design and implementation process. Established projects that only recently began using AI are just as welcome as projects that were AI-assisted from the beginning.

You do not need to minimize, conceal, or apologize for your use of AI. We ask only that people be honest about how their projects were developed, engage sincerely with technical questions, and remain open to constructive discussion.

Whether you are an experienced compiler developer, a programming-language researcher, an independent creator, or someone experimenting with your first interpreter, this should be a safe and welcoming place to share your work.

What to Post
Post anything that you think the community would find interesting, helpful, or inspiring. Feel free to share your thoughts, questions, and links to your project repo or website.

Community Vibe
We're all about being friendly, constructive, and inclusive. Let's build a space where everyone feels comfortable sharing and connecting.

How to Get Started

  1. Introduce yourself in the comments below.

  2. Post something today! Even a simple question can spark a great conversation.

  3. If you know someone who would love this community, invite them to join.

  4. Interested in helping out? We're always looking for new moderators, so feel free to reach out to me to apply.

Thanks for being part of the very first wave. Together, let's make r/AIprogrammingLanguage amazing.


r/AIprogrammingLanguage • • Sep 21 '26

Vx is a systems programming language for heterogeneous computing

8 Upvotes

Most languages treat the accelerator as infrastructure: you write math, and a large opaque runtime decides how to ship it. Vx treats it as semantics. A tensor pinned to NPU high-bandwidth memory has a different type from one in host DRAM, and crossing between them takes an explicit transfer() — even when the hardware boundary is free.

On Apple's unified memory that transfer compiles to almost nothing. It is still written down, because data locality should be provable by reading the source rather than by profiling the binary.

// Two matrices already resident in NPU memory.
fn custom_matmul(
    a: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>,
    b: Pinned<Tensor<f32, [4, 4]>, Topology::NPU[0]>)
    -> Verified<Tensor<f32, [4, 4], Memory::NPU_HBM>> {

    let mut result =
        Tensor<f32, [4, 4], Memory::NPU_HBM>::uninit();

    // Dispatch the computation to the accelerator.
    spawn on(Topology::NPU[0]) {
        for i in 0..4 {
            for j in 0..4 {
                result[i][j] = 0.0;
                for k in 0..4 {
                    result[i][j] += a[i][k] * b[k][j];
                }
            }
        }
    }

    return Verified(result);
}

More at: https://vxlang.org


r/AIprogrammingLanguage • • Aug 16 '26

I vibe-coded a programming language. It got slightly out of hand.

Thumbnail flooooooooooow.github.io
8 Upvotes

I present to you Flow, which started from the fairly simple question:

what would a systems language look like if a huge amount of its development was driven through LLMs?

What started off as a simple experiment has become an actual compiler + language ecosystem.

Flow is statically typed and aimed at writing relatively compact code without giving up native performance. It has multiple compilation paths, including C and MLIR/LLVM.

A lot of people wonder about whether or not an LLM can generate a compiler from a schema.

I think it's time we start asking ourselves whether we can construct enough feedback and verification around an LLM that the language remains coherent while the implementation is scaled up.

I've learned a lot of things about how best to use LLMs as tools, as well as a lot of the science behind traditional compiler engineering, in the process. By embracing the tooling and having fun, there's a lot of cool stuff to be made.


r/AIprogrammingLanguage • • Oct 16 '26

madc v0.105.0 — Live C/C++ REPL function redefinition, and faster compilation

7 Upvotes

I've released madc v0.105.0, with some substantial improvements to its interactive C/C++ REPL, compilation performance, and portability.

For those unfamiliar with it, madc is a self-contained C/C++ compiler with JIT execution, native executable output, and an interactive REPL, without requiring GCC, Clang, or installed headers or development toolchain.

What's new

  • Live function redefinition — redefine a C or C++ function in the REPL and subsequent calls use the new implementation, even from previously compiled callers or existing function pointers.

  • Live variable and type redefinition — reinitialize existing variables and redefine classes or structs interactively, with versioning when a type's layout changes.

  • Interactive source editing — the REPL includes an ex-style editor. Copy, modify, search and replace code directly in the session, with changes taking effect immediately.

  • Restart and Run All — replay the entire REPL buffer in a fresh session, similar to working with a notebook.

  • Faster compilation — changes to the precompiled header representation allow madc to load only the parts a program needs, substantially reducing compilation overhead.

Performance

The updated README includes benchmarks against GCC 13.3 and Clang 18.1 on Ubuntu 24.04:

TaskmadcGCCClang
C++ Hello World (JIT vs compile/link/run)83 ms170 ms207 ms
C++ STL example (JIT vs compile/link/run)209 ms252 ms275 ms
C Hello World (JIT vs compile/link/run)9 ms21 ms37 ms

These are end-to-end timings for the specified workloads, not claims that madc universally outperforms GCC or Clang.

C/C++ compatibility

Current results against external compiler test suites include:

  • C17: 99.2% of GCC's c-torture/execute

  • C11: 220/220 on the third-party c-testsuite

  • C++98: 81.3%

  • C++11: 77.3%

  • C++17: 43.2%

  • C++20: 53.8%

The C++ figures are pass rates for selected GCC test-suite subsets, not claims of complete standards conformance.

madc remains available for Linux, Windows, and macOS (Intel and Apple Silicon). The companion IDE, madcide, has also been updated to v0.8.0 with the live REPL improvements.

GitHub: https://github.com/derekbsnider/madc

Release: https://github.com/derekbsnider/madc/releases/tag/v0.105.0


r/AIprogrammingLanguage • • Oct 07 '26

Protos: a programming language designed by a human, implemented with AI

7 Upvotes

I've been working on Protos, an experimental prototype-based object-oriented programming language built on GraalVM/Truffle.

Project links:

Protos is based around a deliberately small semantic core: objects and slots, delegation, object execution contexts, and closures as the fundamental executable value. Futures, structured tasks, isolated parallel execution and Actors are intended to fit into that same object/message model rather than becoming separate subsystems.

I originally wanted to discuss Protos in r/ProgrammingLanguages, but projects whose implementation depends on LLM-generated output are not welcome there. That makes this community a much better place to explain not only the language, but also how I am actually building it.

How AI is used in Protos

I want to be completely explicit about this.

The ideas, language design and decisions are mine. The implementation is currently AI-generated. I have not personally written a single line of Protos code so far.

This is intentional rather than something I am trying to hide.

I've been thinking about the ideas behind Protos for roughly twenty years. What AI gives me today is something I didn't have before: enough implementation manpower to explore those ideas at a scale and speed that would otherwise be unrealistic for me working alone.

I'd rather see how far I can take the language with AI than deliberately move much more slowly just so I can say that I personally typed every line of code.

But I don't treat AI as the designer.

My workflow currently has two distinct AI levels:

  1. Research AI It investigates a problem before implementation: existing languages, runtimes, academic or production approaches, upstream implementations, alternatives and trade-offs. Research does not implement anything and it does not make the final decision.

  2. Implementation AI Once I've made a decision, a separate implementation stage receives a constrained task describing what has been decided, the invariants it has to preserve, and the tests/evidence required to consider the work complete.

Between those two stages, I make the decisions.

I decide the semantics, accept or reject architectural alternatives, change direction, define priorities, decide what gets implemented and ultimately decide whether an implementation actually represents the language I want to build.

So the model is approximately:

human idea → AI research → human decision → AI implementation → tests/evidence → human acceptance

AI provides manpower.

It does not own the language.

Why work this way?

Because my limiting resource isn't ideas. It's implementation capacity.

I'm one person.

Without AI, I could either reduce the scope of what I want to explore or spend much longer implementing each idea myself.

I prefer a third option: use AI as engineering manpower and see how far I can push the design.

For me, the interesting question isn't whether I can personally type every line of a programming language.

It's whether I can design a coherent language, make the important decisions myself, direct considerably more implementation capacity than one person traditionally has available, and still maintain enough discipline that the implementation remains subordinate to the design.

The process is public

An important part of this experiment is that I'm not asking anyone to take that distinction on faith.

The source is public:

https://github.com/guillermomolina/protos

And the engineering process is also public:

https://github.com/guillermomolina/protos-project-docs

That second repository contains the durable record behind the project: investigations, architectural and semantic decisions, implementation evidence, measurements, audits and closure records.

The live work is also visible through the project's issues and project board:

https://github.com/users/guillermomolina/projects/1

So if I claim that a decision was mine rather than something an AI silently decided while generating code, there should increasingly be a public trail showing the research, alternatives, decision and subsequent implementation work.

About the language itself

What I'm most interested in discussing here is still the language, not merely the development method.

Protos has no classes. Objects delegate directly to other objects.

Some of the ideas I'm exploring include:

  • objects and slots as the basic state model;

  • prototype-based delegation rather than classes;

  • execution contexts that are themselves objects;

  • lexical bindings represented through that object/context model;

  • closures as the single executable value rather than having separate Function and Method value kinds;

  • Futures, structured Tasks, isolated parallelism and Actors integrated into the same object/message model;

  • keeping language mechanisms composable instead of accumulating unrelated special cases.

The website gives a much more approachable overview than the implementation repository:

https://protos.guillermomolina.com

I'm especially interested in criticism around:

  • whether the semantic model is understandable and coherent;

  • where the prototype/object model becomes surprising;

  • closures and execution contexts;

  • delegation, traits and operators;

  • concurrency and the relationship between Futures, Tasks and Actors;

  • places where I've introduced complexity that isn't justified;

  • ideas from other languages that Protos should study or challenge.

The language is still evolving considerably.

I'm not looking for people to agree with the design. Quite the opposite: useful criticism of the semantics, architecture and assumptions is exactly what I'm looking for.

And given the subject of this subreddit, I'm also very interested in the development model itself:

What happens when an individual language designer can use AI not just for autocomplete, but as separate research and implementation manpower while keeping design authority and decision-making human?

I don't know yet how far that model can go.

Protos is partly an attempt to find out.


r/AIprogrammingLanguage • • Oct 03 '26

madc v0.101.0 -- REPL and "Chthonia"

Post image
7 Upvotes

MadC now has a REPL, and its editor becomes a teaching IDE modeled after Thonny.

Run madc with no program file and you are in an interactive C/C++ session that behaves the
way Julia and IPython do: what you define in one entry is there in the next, results are named so you can reuse them, and the session can tell you what you have built. On top of it, madcide gains a plugin system, and the first plugin built with that system is Chthonia, a teaching IDE modelled on Thonny.

So I've been working on the REPL, inspired by Julia, IPython and Cling, as well as a version of the IDE inspired by Thonny (the Python-teaching IDE), to make a C/C++ teaching IDE with REPL.

I've called the IDE "Chthonia" (the ch is silent). Chthonia is the Greek Goddess of the Earth and Underworld, like how C is the language of the OS. The "C" can be for C/C++, the "h" for helping, the "thon" for Thonny-like, and the "ia" from Julia.

REPL-mode is inherent to madc now, and provides an interactive REPL shell if run without arguments:

$ madc
madc 0.101.0. Ctrl-D exits.
madc> int sq(int x) { return x * x; }
madc> sq(7)
49
madc> ans + 1
50

r/AIprogrammingLanguage • • Oct 03 '26

I’ve been building a programming language with AI assistance — Mah

7 Upvotes

I’ve been building a small programming language called Mah from scratch, and this seemed like the right subreddit to share it because AI has been part of the development process.

Mah currently has:

  • a hand-written lexer, parser, resolver and compiler

  • its own portable bytecode format and VM

  • a static type checker with inference

  • structs, enums, traits, pattern matching, generics and closures

  • try / catch / typed error sets

  • a standard library (std:json, std:fs, std:math, std:regex, etc.)

  • runtime reflection, decorators and hooks

  • a real LSP with diagnostics, hover, completion, definition and rename

  • a formatter

  • Neovim and VS Code integrations

  • a second VM/runtime implemented in Rust

The compiler/tooling are mostly Python standard-library code, with the Rust implementation being an optional native runtime.

The interesting part for me hasn't really been inventing another syntax. It's been figuring out how all of these pieces fit together: resolution, closures, bytecode, runtime metadata, reflection, the type checker and the LSP all sharing the same underlying representation.

GitHub: https://github.com/sina-salahshour/mahlang

I'm particularly interested in feedback on the language/runtime architecture and on places where AI assistance helped versus places where it made the implementation harder.


r/AIprogrammingLanguage • • Oct 12 '26

Objective 9c: A CSP actor based language for 9front and other Plan 9 OS

6 Upvotes

I've been working on a new native system language for 9front where objects are CSP actors, and the application can act as a 9p file server (though calling serve() is entirely optional).

When utilizing the file server, interacting with class methods can be done entirely through standard Plan 9 tools (ls, cat, etc.). Data moves around using an NDB-derived text format called 'libtab'. The language currently has a small stdlib, a small UI library, and allows for writing Plan 9 C directly as inline functions. The most recent feature I've added is actor-controlled filetrees utilizing namespaces and an MVC pattern.

The language transpiles to Plan 9 C, so it drops cleanly into the typical build system (mk, 6c, 6l, etc.). The runtime is written in Plan 9 assembly for x86, with a C fallback for non-x86 architectures.

I haven't been able to test the non-x86 fallback yet as I lack the necessary hardware. If anyone here has non-x86 setups and is willing to help test, or just wants to poke around and provide feedback, I'd greatly appreciate it.

I've included extensive documentation in the repository covering the architecture, standard library, and how to get started. You can find the code and docs here:

https://github.com/kiljoy001/objective-9c


r/AIprogrammingLanguage • • Oct 12 '26

U: Ultra-safe new programming language for LLMs and Humans to collaborate

Thumbnail
ulanguage.org
6 Upvotes

r/AIprogrammingLanguage • • Sep 29 '26

Building VBX: An iterative, compiled Basic-to-C99 language with memory pooling and multi-editor tooling

6 Upvotes

Hey everyone!

I wanted to share an ongoing language design project I’ve been building: VBX (Visual Basic X).

Instead of a one-shot prototype or another interpreted toy running inside Python, the goal was to build a real, production-capable procedural language that compiles to standalone native binaries with zero runtime dependencies.

Architectural Decisions & Implementation

  1. Compiler Host (Go) -> Target (C99):

    • The compiler itself is written in pure Go without external packages, leveraging the standard library for AST construction, multi-pass type inference, and process orchestration.

    • Emits clean, standard C99 code and invokes the system toolchain (GCC/Clang) with -O2 optimizations.

  2. Solving the Runtime Memory Problem (Ring-Buffer Pool):

    • Naive transpilation of string operations inside tight loops (s = s & "x") typically floods malloc without high-level deallocation.

    • We implemented a fixed static ring-buffer memory pool (vbx_alloc_str with 256 rotating slots of 4KB) directly in the emitted C runtime. Tested under 10,000 continuous iterations with zero heap leaks and flat memory usage.

  3. Language Syntax & Semantics:

    • Visual Basic-inspired syntax: Dim, Const, If/ElseIf/Else, For/Next, While/Wend, Do/Loop, Select Case (supporting both string and numeric comparisons natively via chained branches), Sub, Function, and 1D fixed arrays.

    • Built-in primitives: Native OS dialogs (MsgBox, InputBox), standard File I/O, and string manipulation routines.

  4. Testing & Tooling:

    • 42 integration and unit test suites running via go test ./....

    • Complete multi-editor support repository: official VS Code extension (available on Visual Studio Marketplace), plus packages for Sublime Text, JetBrains, Vim/Neovim, Notepad++, Emacs, and Micro.

    • Currently designing Phase 2: a dedicated desktop IDE with a visual form designer (vbx-studio).

Repository: https://github.com/M5Devs/vbx Editors: https://github.com/M5Devs/vbx-editors

Would love to discuss the language design trade-offs, transpiler architecture, and experiences building full-scale compilers using modern agentic workflows!


r/AIprogrammingLanguage • • Sep 29 '26

Nyx isn’t dead — it’s Rove now. Here’s where the language actually stands.

Thumbnail reddit.com
6 Upvotes

r/AIprogrammingLanguage • • Sep 28 '26

Loom: a language built around mathematical structure, with algorithm discovery as the long-term goal

6 Upvotes

I’m developing Loom, an experimental programming language and compiler written in Rust, and I’m looking for people interested in helping build it.

The idea connecting the language to its larger ambitions is this:

Mathematical structure should be something a programming system can represent, use and search over—not only something a programmer relies on when choosing an algorithm.

That starts with how programs are expressed and compiled. The longer-term goal is an environment that helps discover algorithms by finding useful mathematical properties and alternative representations of problems.

What Loom is trying to express

Loom uses a categorical core representation. Programs are expressed internally through operations and their composition, with products, alternatives and the relationships between inputs and outputs represented explicitly. The purpose is not to make every program look like a category-theory textbook. It is to give the compiler a structured account of the computation that can support analysis, transformation and different implementations.

The broader language design is organized around structures, relations and sorts, together with theories, models and laws.

A theory describes abstract domains—sorts—and the operations, relations and laws associated with them. A model interprets those declarations using particular value spaces and operations, with evidence for the properties it claims. For a programmer, the intended benefit is that a library can communicate more than an interface. It can also communicate mathematical knowledge that other code and the compiler can use.

An interface might say that an operation combines two values. A richer contract could establish that the operation is associative, has an identity, preserves an ordering, or interacts with another operation in a particular way. Those properties can make different implementations or algorithms available.

The interpretation matters. An algebraic law that holds for mathematical integers does not automatically hold for checked machine arithmetic with observable overflow. Likewise, a transformation that preserves a final value might still change an earlier effect or failure.

Loom’s intended approach is to connect mathematical properties to the actual operations and conditions under which they apply, alongside effect, failure and usage information. Static evidence would support compilation without becoming proof objects carried through ordinary runtime computation.

The aim is not just stricter checking. It is to make more powerful transformations possible because the system has the information needed to justify them.

From transforming code to transforming the formulation

There is a significant difference between improving an implementation and discovering that the computation admits a better formulation.

A programmer might express a problem as a sequence of steps, then realize that entire sequences can be summarized and composed. A collection of constraints might have an algebraic interpretation that makes a specialized solver applicable. A large problem might become manageable after finding a decomposition with a sufficiently small boundary between its parts.

In each case, the important insight is not a local code rewrite. It is a different representation of the problem.

I want Loom to provide a foundation on which those representation changes can themselves become objects of computation: described, proposed, composed, checked and reused.

That is the motivation for the Structural Representation Engine and LoomLab.

Structural Representation Engine: searching for useful representations

The proposed Structural Representation Engine, or SRE, would investigate which mathematical structures a problem can be related to, and what those relationships make possible. That could mean recognizing a property already present. It could also mean constructing a new representation in which a useful property becomes visible.

A few examples illustrate the direction:

Repeated computation could become an algebra of summaries. Rather than execute every step, the system might find a compact summary of a block’s relevant behavior and an operation for composing summaries. Where the correspondence holds and summaries remain compact, that could support faster repeated evaluation, incremental updates or queries over a much larger computation.

A constraint problem could become an algebraic problem. If its constraints admit an exact formulation as linear equations over a finite field, the system could use elimination rather than treat them as an unrestricted combinatorial search. The useful discovery is the formulation and its connection to the original constraints—not simply recognizing the word “linear.”

A large optimization problem could become a network of boundary summaries. Instead of solving components in isolation and hoping their solutions fit together, the system could retain precisely the information needed to describe how each component interacts with the rest. Finding a useful decomposition and a compact, sufficient boundary representation could change the algorithm substantially.

These are examples of the kinds of relationships I want the system to explore, not claims that Loom currently discovers them.

Different representations could also expose different metrics, invariants and bounds: symmetry, rank, separators, residuals, approximation gaps, or measures that help choose productive search directions.

Not every useful representation needs to be geometrical, and not every useful measurement needs to prove something. A heuristic can guide a search; a valid bound can justify pruning; an exact correspondence can authorize replacing one computation with another. The system should preserve those distinctions while being able to exploit all three.

LoomLab: turning exploration into reusable discoveries

LoomLab would be the experimental side of the system. Its role would be to propose hypotheses and representations, construct candidate methods, look for counterexamples, evaluate performance, and retain useful results. AI, symbolic methods, search algorithms and human input could all contribute to that process.

The long-term ambition goes beyond choosing an algorithm from a fixed catalogue. I want to investigate whether the system can discover new summaries, decompositions, invariants or combinations of transformations that lead to useful algorithms. The valuable output would not necessarily be just one solution or one generated program. It could be a reusable relationship:

Problems satisfying these conditions admit this representation, which exposes this property and enables this algorithmic construction.

That relationship could then become part of the mathematical knowledge available to later investigations. A new discovery would expand what the system can work with, rather than disappear into an isolated experiment.

The larger goal is a feedback loop between mathematical understanding and algorithm construction.

Correctness and usefulness would remain separate questions. A representation can be mathematically valid but expensive to construct. A method can perform well on the examples that suggested it and fail elsewhere. The cost of discovering, translating and checking a representation has to be included when evaluating whether it helps.

But that is also what makes the research interesting: finding representations that are not merely elegant, but computationally useful.

Why connect this to a language?

The architectural bet is that these capabilities would benefit from a shared semantic foundation.

The problem specification, mathematical properties, representation changes and executable algorithms should be able to refer to the same operations and relationships. A transformation should retain its assumptions. A discovered method should have a route to compiled code. A library’s established properties should be available beyond the particular application that first needed them.

I’m not claiming that this requires Loom, or that category theory automatically supplies an algorithm-discovery engine. The question is whether designing the language and surrounding tools around these connections can make the process more coherent, extensible and reusable than repeatedly connecting separate representations by hand. Ordinary compilation would not need to run an open-ended research search. The compiler would use established capabilities; LoomLab would explore possibilities and develop new ones.

Loom is the language and compilation foundation. SRE would explore structural possibilities. LoomLab would investigate what can be discovered through them.

Where things stand

There is an existing Rust compiler implementation. Recent work has connected program-structure analysis to checked call and recursive-effect resolution, but the ordinary end-to-end execution path is still being completed. Compiler-evidence representation also has unresolved scalability work.

The broader mathematical language features are at different stages of design and implementation. The SRE/LoomLab discovery loop described here is the research ambition, not a delivered capability. I do not yet have a demonstrated general advantage over established languages or solvers.

Development has involved substantial AI assistance. I’ve been directing the project and coordinating implementation and review, but I want more independent human judgment involved—especially people willing to challenge assumptions and simplify the architecture.

Looking for collaborators

Experience with compilers, Rust, programming-language semantics, algorithms, optimization, formal methods or mathematics would be especially useful, but those are preferred backgrounds, not entry requirements.

I’m interested in teaming up with anyone willing to contribute seriously. That could mean implementation, testing, mathematical experiments, visualizations, documentation, examples, or learning enough to take ownership of a manageable part.

I’m not asking people to accept a finished architecture or commit to the entire vision. I want collaborators who can help decide which ideas deserve to survive, which need a better construction, and which should be dropped.

A practical starting point would be one narrow demonstration: express a problem, establish a useful alternative representation, derive an algorithm through it, and assess the result against a reasonable baseline.

The ambition is a system that helps discover better ways to compute by discovering better ways to represent the computation. The immediate goal is to find people interested in building and testing that idea together.

Comment or message me with what interests you and what you’d enjoy working on.

https://github.com/Gregory-Cross/Loom


r/AIprogrammingLanguage • • Sep 21 '26

Bil

Thumbnail bil-lang.org
6 Upvotes

Bil: an extension to Go for parallel processor systems.

Bil and Go both have concurrency models that are heavily inspired by Hoare’s CSP.

Go is a general-purpose language that borrows CSP’s channel-and-process ideas but relaxes them with buffering, dynamic concurrency, and conventional shared-memory mechanisms

Bil is a special-purpose language for parallel processor systems; influenced by CSP, by Go and by May’s occam. Built on the Go toolchain, it constrains and shapes the Go concurrency model to encourage a higher level of discipline as needed by parallel systems. Bil helps coders to reason about their process models and to selectively place processes on to physical processors.

package main

func main() {
	c := make(chan int)

	par {
		seq {
			c <- 42
			c <- 99
		}
		seq {
			var x, y int
			c -> x
			c -> y
			println(x)
			println(y)
		}
	}
}

r/AIprogrammingLanguage • • Sep 17 '26

U: a hyper-safe programming language for Humans and AI Agents to collaborate

Thumbnail
ulanguage.org
6 Upvotes

Get ready to level up your programming game.

It’s 2026. This language makes you leave all your footguns 🦶🏾🔫 at the door.

It gives LLM all the context they need to stop hallucinating and start writing safe code by default.

It actively prevents supply chain attacks, and more.

It prevents SQL injections and other string interpolation security nightmares

It features exact floating point arithmetic, so 0.1 + 0.2 == 0.3 and no need for crazy workarounds.

It lets you write vectorized GPU-accelerated and CPU-paralllized code without the need for CUDA

It doesn’t even need a garbage collector.

It is its own preprocessor.

Intrigued? Check it out. The compiler is hosted so there is nothing to install. You can try it yourself in the playground. Your binaries are compiled to WASM so they run in your browser. Yes, even with WebGPU acceleration. You can do inference with U.

Oh, one more thing…

U comes with js-based transpilers that you can run in your browser, to transpile your existing PHP, Python, Javascript, Typescript… to U. Then the U compiler finds lots of issues you can fix, and source maps let you see it in your own code.

Been working on this for years but thanks to Claude i was able to make it a realiry. I would love feedback and discussion from anyone who actually looks thoughtfully at the spec and maybe plays around with it in the playground.


r/AIprogrammingLanguage • • Sep 07 '26

The Monad language

6 Upvotes

I wanted to share my hobby project, Monad, which is an early stage dependently typed functional language that compiles to LLVM.

I developed the first Rust interpreter by hand and I gradually started to use more LLMs since it meant I could do more with higher quality and spend more time on design and experimentation. I consider the move to using AI agents for coding is similar to the introduction of compilers rather than writing assembly.

I wanted to have something that could be as performant and safe as Rust, but with the ergonomics, verifiability power and expressiveness of languages like Haskell, Lean, ATS or Idris. That is quite ambitious so I might not succeed.

A simple hello world example:

def main : IO Unit := println "Hello World!"

The latest milestone is that it can now compile itself and is therefore self hosted. The documentation is a bit outdated, but I will update it soon.

https://github.com/monad-lang/monad

https://monad-lang.org

There is still a lot to be done.

If you are interested in discussing more and following development come over to the Zulip https://monad-lang.zulipchat.com


r/AIprogrammingLanguage • • Aug 20 '26

madc v0.92.1 released — std::format, std::println, php::print_r, php::var_dump

6 Upvotes

I just released madc v0.92.1, the download release for the v0.92 line and the first published binaries for all three platforms since v0.82.0.

Packages are available for:

  • Linux — .deb and .rpm

  • Windows — zip

  • macOS — Apple Silicon and Intel tarballs

A few of the more interesting additions:

  • std::format, std::print, and std::println are built directly into madc — no includes or header parsing required. Literal format strings are checked at compile time, including invalid indexes, malformed strings, and incompatible presentation types.

  • std::format returns a real std::string, and formatting behaviour has been tested against libstdc++ with 1,430 generated oracle cases, including floating-point and hex-float formatting.

  • cout << var now works with zero includes: It also works with <iomanip> features such as setprecision, setw, and setfill.

  • UFCS support in the madc dialect — free functions can be called like methods, and methods can be called like free functions.

  • PHP-style debugging helpers for any madc type: php::print_r(x); php::var_dump(x); These work on structs, classes, containers, nested objects, arrays, and var, with cycle detection and human-readable type names.

  • Range-based for loops now work naturally with PHP-style arrays, including value/var elements and auto.

  • var/value continues to mature — constructors work naturally in expressions and loops, .size() / .count() semantics have been cleaned up, and php::array_push() now behaves as a single overloaded function returning the new element count.

  • Headerless libc calls now get proper function signatures, so things like:floorf(3.9f) pass a real float rather than falling through old C-style variadic promotion behaviour.

  • And, finally, madc --version tells you which build you're actually running.

The direction continues to be: keep C and C++ underneath, but remove a lot of the friction when you're just trying to write a small program or script.

So something like:

var x = 42;
println("x = {}", x);

doesn't need a collection of headers or setup before you can get to the actual program.

With v0.92.1, all of this is available in the downloadable builds for Linux, macOS, and Windows.


r/AIprogrammingLanguage • • Aug 03 '26

Hello, thanks for the invitation - Building my programming language :)

6 Upvotes

Hello everybody

Well, I was one of the users who intended to introduce the programming language I’m developing on the r/ProgrammingLanguage subreddit.

I’ll tell you a bit about myself and the language I’m creating—without going into too much detail, since it’s set to launch later this year.

I have a degree in Law (yes, really) and a postgraduate degree in Artificial Intelligence Engineering. "WTF? What does law have to do with computing?"

I’ve been involved with technology and programming throughout my life, but due to life circumstances, I ended up getting a law degree. However, I’ve always loved electronic devices (like VCRs), video games (I owned a Mega Drive/Genesis and a Sega Saturn), and computing in general (I got my first computer in 2001). I know how to program a bit in Python (I consider myself average) as a hobby; even before law school, I took various IT courses—basic computing in 1997 (Windows 95), programming logic (2001), Delphi 5 (2001), CorelDRAW (2002), etc. But as I mentioned, life took a different turn: I entered the public sector, earned my law degree, and now work at a courthouse.

Given that background, how did I end up building a new programming language? At my job—specifically in the department where I used to work—I had a falling out with my former boss and looked for a new position within the courthouse. I introduced myself to the deputy chief of the new department, and he was impressed that I had a background in Artificial Intelligence Engineering (this was in 2023). I was hired and started working there, taking useful courses like Power BI and SQL. It was decided that I would work on creating a set of regex patterns to automate court processes. That was my first real encounter with LLMs in a computing context: ChatGPT 3.5 was a huge help, assisting me with Python scripts to generate the regex patterns I needed for my tasks.

I spent over a year—the entirety of 2024—creating, refining, and fixing regex patterns for sorting through lawsuits. In early 2025, I received some difficult news: my son had leukemia. He is doing well and undergoing treatment, with a high chance of recovery once he completes the two-year treatment plan. I mention this not for cheap dramatic effect, but because my son's condition made me eligible for remote work—a policy at my court for employees with family health issues. My request was approved, which is notable because, while such arrangements were granted en masse during the pandemic, most departments had almost completely eliminated them afterward. While I was at home caring for my son during his treatment, my boss reached out to ask if I could help create a departmental chatbot to train new colleagues. It was intended to use Microsoft Copilot and specific internal files. So, with Gemini's help, I took all the manuals from the various subordinate departments and converted them into a question-and-answer JSON format suitable for training LLMs. I tested the data locally using TinyLLM, but it was ultimately used to "feed" Copilot. It worked excellently, requiring only a few minor adjustments.

During one of my interactions with Gemini, I asked if it could guide me in creating a programming language; it replied, "Sure, what kind of language do you have in mind?" What started as mere curiosity evolved into a project I’ve been working on for over a year now, dedicating at least five hours every single day—weekends included.

I originally had an idea for a low-level programming language focused initially on general systems and games. However, as development progressed, I narrowed the language's scope to a specific niche: a programming language focused on artificial intelligence for embedded devices, IoT, and consumer CPUs.

What defines an AI-focused programming language? It features simple, low-level syntax with low complexity and low cognitive load—qualities that benefit humans as well. In other words, both humans and AIs could program in it seamlessly. It will also include features that enable AI solutions to fully leverage silicon performance, avoiding resource-heavy abstractions that burden AIs and consume excessive energy, time, and water for data center cooling. :)

What was my development process like? I spent practically 10 months working on my "B" compiler in Python, using a stack of Python, Lark, Clang, and LLVM Lite. After countless tests, ideas, and drafts—and constructs I created, overhauled, deleted, and resurrected—February arrived with the "B" compiler generally quite mature. That was the moment to start writing code in the very language I had created. During those 10 months, I relied almost exclusively on Gemini. However, Google began charging for Gemini usage in January 2026; after receiving a $500 bill—and getting pissed off at the cost, since I had insisted on using their API directly via AI Studio—I looked for alternatives. I subscribed to ChatGPT to access Codex and Claude; I liked Claude, and I’m still using it today.

After three and a half months, in June 2026, I managed to make my language self-hosting. Now, I’m refining it and handling the finishing touches. :)

I plan to launch it with two base compilers:

ABC Compiler: Focused on solutions of low-to-medium complexity and designed for building other compilers or programming languages. Anyone wanting to create their own programming language won't need to resort to C or Python (as I did with my use of various libraries); instead, they can use my language's base compiler.

Full Compiler: Focused on AI.

"But what does your language actually do that makes you claim it's focused on AI?" One example is the calculation of intrinsic tensors directly within the compiler, maximizing silicon performance without abstraction layers—and that’s just one feature. Anyway, I’m currently refining the "ABC" version, and once it’s ready, I’ll start building the "Full" version.

So, that’s my story: I’m taking advantage of working remotely to stay home with my son while I build my own programming language. :D


r/AIprogrammingLanguage • • Jul 31 '26

My reason for creating this Reddit community

6 Upvotes

While implied in the community description, I wanted to elaborate a bit to get some activity going on here, and I figured this post could serve as a discussion point.

Over the past few months, many of the programming related communities have began enacting AI content bans, and this overlaps a massive industry push for more AI adoption, which puts us at a sort of crossroads and an impasse for developers in general.

On one hand, we are being compelled to adopt these tools in our professional careers to advance the agendas of our employers, and on the other, attempts to use these tools for our personal projects are being shunned by communities of our peers.

While I understand the need to protect from the sudden influx of "slop" projects, I believe that the use of AI to assist with development should serve more as a disclaimer than a barred door.

AI tools are not going away, so banning their use is pointless. While I will be the first to agree that "agentic development" certainly has its own set of flaws and pitfalls, it requires us to think differently, and thus to work differently.

For me personally, AI assisted development has allowed me to take a project which I have been slowly working on for over seven years (due to lack of free time) and push it forward far more than I would have been able to on my own. I simply do not have the spare time I did when I was in my early 20s.

When I thought my project was now far along enough for community input and discussion, I came to find that it was a forbidden topic because I had used AI -- even though I had worked on my project for seven years without any AI assistance.

I am certain I am not the only developer facing this, and while there are lots of programming communities that are AI-oriented, my project is specifically a programming language, and the r/ProgrammingLanguages Reddit community has enacted exceedingly strict anti-AI rules.

Not only could I not create a new post about my programming language, I was banned just for mentioning it in a comment on a post.

Thus I decided to create this community for this forbidden topic.


r/AIprogrammingLanguage • • 3d ago

AiLang, artificial Intelligence Programming Language Self hosting x86_64 programming language with performance comparable to or better then gcc -03 llvm clang

Thumbnail
github.com
5 Upvotes

I’m a contributor to this project. The author doesn’t really do promotion or social media, but he said I could share it here to get some early public feedback.

What it is: a language designed around intelligibility, performance, and code quality. A big chunk of the repo is demo, test, and stress code used to validate the language and compiler.

What you get:

  • A self-hosting compiler with throughput around 15k LOC/sec

  • Fully self-contained: no make, no external linker. The compiler ingests every file following its path-based naming scheme and handles the whole stack end to end, including ELF generation on the backend

  • Self-hosts its ~160k LOC codebase in about 10–13 seconds on old hardware

  • Tight, minimal output: statically compiled, no libc dependency

  • Targets x86-64 with SSE2 and the System V ABI, so anything from roughly 2004 onward

  • Runs natively on Linux, with a Haiku OS runtime backend as well

What it does well:

  • Makes deep, complex systems code much easier to read

  • AI agents produce high-quality, performance-oriented code in it with little effort

  • Strong debugging and code analysis tools

  • A VS Code plugin, which I’ll update this week for the new enhanced compiler

Docs and examples: 20+ programming and library manuals, 150 demo programs, and dozens of dev regression tests. These also work well for cache-warming long-context models. So far DeepSeek 4+, Claude, and Grok have all produced excellent low-level code with it.

The lead dev says it’s coming out of low-key mode around New Year’s. Until then, I’d love to hear what people think.


r/AIprogrammingLanguage • • 3d ago

Tessera: a tensor-first compiled language. I designed it and wrote the first version by hand, then built most of the rest with Codex and Claude

5 Upvotes

Hi! Someone suggested I share this here. Tessera is an experimental, tensor-first language for numerical computing and data analysis. It compiles to native code through LLVM, and it was built by me together with AI coding agents.

GitHub: https://github.com/dyanos/csec-
(The repo name csec- and the compiler binary csec++ are historical names; the language is Tessera.)

Who did what

  • Me, by hand (late 2024 to early 2026): the language concept and design, the first lexer and parser, the AST, LLVM IR generation, constructors, C++ name mangling, external functions, and the early LaTeX-style math syntax.

  • OpenAI Codex: the native runtime, tensor and simulation features, native library interop, templates, and the first self-hosting bootstrap.

  • Claude (Claude Code): the ownership and move checker, async/await, Erlang-style microthreads, most of the standard library, support for LLVM 18 through 23, Parquet/CSV data frames, and import aliases. About 110 of the ~200 commits are co-authored with Claude.

What I learned about building a language with agents

  • Tests are the real spec. The agents are very productive but will confidently break things. I keep positive and negative fixture suites, ownership suites, and concurrency and stdlib tests, and the same suites run through two compilers: the C++ one and a self-hosted one.

  • Self-hosting is a great lie detector. A second compiler written in Tessera has to compile itself and reproduce the same output (a fixed point). A codegen bug the agent "fixed" often shows up only one stage later, and the fixed-point check catches it.

  • My job changed. I went from writing code to deciding semantics, reviewing diffs, and designing verification. Design decisions such as strict-by-default ownership and tensors as a core type stayed with me. The agents were best at the large, well-specified implementation work.

  • Agents make the same subtle mistakes repeatedly. Examples are an LLVM API that changed behavior silently between versions, and build tools that didn't notice changed header files. Writing these down as project notes for the agent helped a lot.

A taste of the language

// Tensors are a core type, with the shape in the type
def affine(x: Tensor<Double, 1, 3>,
           w: Tensor<Double, 3, 2>,
           b: Tensor<Double, 1, 2>): Tensor<Double, 1, 2> {
    return (x @ w) + b;
}

// Strict-by-default ownership: explicit move `<-` and borrow `&`
val acct: Account = new Account(100);
peek(&acct);        // borrow, acct still usable
close(<- acct);     // move
// using acct now -> compile error: "use of moved value 'acct'"

// Erlang-style microthreads
import std.microthread

def main(): Int {
    val parent = self();
    val worker = spawn([=]() -> {
        val n = receive();
        send(parent, n * 2);
        return 0;
    });
    send(worker, 21);
    return receive();   // 42
}

Other features: arbitrary-precision Nat, built-in Complex/Rational/Quaternion, a symbolic algebra module, async/await, OS threads with channels, pipes, shared memory, and [@DllImport] for calling native libraries. A parallel wc -l written in Tessera runs at about 92% of a hand-written C++ mmap+SIMD version.

Current state

It's experimental. Right now I'm working on performance, starting with std.dataframe. The tensor codegen is still the first, straightforward version: shapes are read at runtime instead of being used at compile time, there's no loop fusion, and some temporaries aren't freed yet. Fixing that is next.

Questions for you

  • How do you verify AI-written compiler code? Do you use self-hosting, differential testing, or something else?

  • Where do you keep design authority, and where do you let the agent decide?

Thanks for reading!


r/AIprogrammingLanguage • • Oct 01 '26

"Regex For Humans" : because regex shouldn’t look like alien language 👽

5 Upvotes

Regex is powerful… but sometimes this:

/^#[0-9A-Fa-f]{6}$/u

feels like you’re trying to decode a message from another planet. 🛸

This is why I did Regex For Humans 🧠✨

Instead of writing regex directly, you write:

start "#"
6 hex digits
end

And it generates:

/^#[0-9A-Fa-f]{6}$/u

🪄 The idea

Write small, readable English rules.

➡️ Understand what they mean
➡️ See the generated regex
➡️ Test examples instantly
➡️ Copy the final regex

No AI guessing. 🤖❌
No mysterious interpretation.

It uses a small, deterministic language where every instruction has an exact meaning.

🔥 It currently includes

🧩 Interactive regex playground
🧠 Explanations for every generated fragment
✅ Live match / no-match testing
💻 CLI support
📦 JavaScript API
📍 Helpful line + column errors
🔒 Runs locally
🚫 No runtime dependencies

For example:

start "INV-"
between 2 and 6 digits
end

becomes:

/^INV-\d{2,6}$/u

Much easier to read six months later. 😅

🎮 Try it

🔗 GitHub
https://github.com/OthmaneBlial/Regex-For-Humans

🛝 Live playground
https://othmaneblial.github.io/Regex-For-Humans/workshop/

The project is still evolving, so I’d genuinely love feedback. 🙌

What would you add?

More syntax?
More recipes?
Support for other regex engines?
Something completely different?

And the big question:

👉 Would you actually use this instead of writing regex directly? 😄


r/AIprogrammingLanguage • • Sep 27 '26

Current Progress of MadC's Next Release

5 Upvotes

I wanted to give an update of what I'm working on to get some feedback and discussion...

I'm not sure how many people here are C and/or C++ programmers, but the current direction I'm taking with madc is to make it a little more like IPython and/or Julia with respect to its REPL experience (that is part of the current arc I am working on, REPL support does not currently exist).

I am neither a Python nor a Julia programmer, but their REPL experience are supposed to be top notch, and while both cling and clang-repl exist, they don't quite measure up, and in fact, installing cling takes up over a Gb of disk space, and the eventual plan is that clang-repl will one day replace cling, and the direction is also such that clang-repl is more like IPython...

Thus, my current plan is to make madc have a REPL mode that is more like IPython and Julia, so more like what clang-repl + cling will eventually become (in the future).

So that's the first arc... and I'm curious what people here think about this idea... like, if you are already a C/C++ programmer, does the REPL experience interest you? Or if you are a Python programmer, would the idea of a small, easy to install and play with C/C++ REPL interest you?

Next... I recently discovered Thonny -- an IDE designed to be very simple and easy for students to learn to use Python... and with the work I've done with madcide as a simple IDE for madc, rather than try to compete with VSCode and/or CLion, what might be much more interesting would be to make madc's IDE much more like Thonny, but for C/C++ (and madc), so that it makes C/C++ easy to use (including interfacing with madc's IPython-like REPL).

Does this concept sound interesting to anyone here?


r/AIprogrammingLanguage • • Sep 21 '26

Why Nyx Became Rove — and Why r/RoveLang Is for More Than Just Rove

5 Upvotes

Rove originally started under the name Nyx.

I liked the name, and a lot of the early compiler work, architecture notes, experiments, and plans were created under it.

The problem was that Nyx was already everywhere.

There were already other programming language projects using the name, tools using the same CLI naming, VS Code extensions, security projects, and plenty of unrelated software using “Nyx” as a brand.

At some point it stopped feeling like my project had its own identity.

So I decided to rename it.

Why “Rove”?

I wanted something short, simple, and easy to remember.

Not a huge fantasy name. Not something that sounds like a company trying too hard. Not a name that needs a paragraph to explain.

Rove felt right because the project itself has always been exploratory.

I move between compiler architecture, language design, runtimes, LLVM, different backends, tooling, systems programming, and whatever problem becomes interesting next.

The project has never really followed a straight line.

It explores.

It roves.

The source extension will still stay .nyx for now. I don't see a reason to break existing files just because the project name changed.


About this subreddit

Despite the name, r/RoveLang is not meant to be only about Rove.

Rove will obviously be one of the main things I post here:

  • compiler development

  • language design

  • experiments

  • benchmarks

  • architecture ideas

  • bugs

  • weird failures

  • releases

  • things that worked

  • things that definitely didn't work

But I also want this to be a place where other people can share their own experiments.

If you're building:

  • a programming language

  • a compiler

  • an interpreter or VM

  • a strange runtime

  • a small operating system experiment

  • embedded software

  • developer tooling

  • a weird hardware/software project

  • a parser

  • a transpiler

  • something low-level

  • or just some technical experiment you think is interesting

you can post it here.

It doesn't need to be polished.

It doesn't need to be a serious product.

It doesn't even need to succeed.

Sometimes the failed experiments are the interesting ones.


The only real rule

Please don't flood the subreddit.

Sharing your work is welcome.

Posting every tiny update as a separate thread, repeatedly promoting the same project, dumping unrelated links, or treating the subreddit like an advertising feed isn't.

Other than that:

show what you're building, explain what you're trying, ask questions, criticize ideas, share failures, and experiment.

Rove may have started this place, but it doesn't have to be the only thing built here.


r/AIprogrammingLanguage • • Sep 17 '26

Klyn 0.1.7

Post image
5 Upvotes