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 • • 1h ago

HQL 0.7.1 - Building a Strongly Typed Data Language with Rust Extensions

3 Upvotes

Over the past few months I've been developing HQL, an open-source, strongly typed functional query language written in Rust. I've just released version 0.7.1, and always keen for feedback.

The idea is something like SQL, but more of a Swiss Army knife for data. I want to use the same language for querying and transforming files, PostgreSQL, Kafka, Spark, Delta Lake, streams, and knowledge graphs.

HQL already supports quite a bit: typed pipelines, aggregations, data contracts, error handling, modules, custom extensions, and even OLTP-style transactions.

Here's an actual example from the Kafka -> PostgreSQL demos. Incoming events are validated against a data contract, valid records go to one table, and invalid ones are routed to quarantine:

tap("order_events_raw")
| validate(EventData)
| fork {
    clean =
        oks()
        | map(e => Event(id = e.id, kind = e.kind, customer = e.customer, amount = e.amount, at = e.at))
        | sink("order_clean"),
    quarantine =
        errs()
        | map(e => Rejected(
            id = match e.value.id { some(Int n) => n, _ => 0 },
            message = e.value,
            rules = e.violations | map(v => v.rule)))
        | sink("order_quarantine"),
}

One thing worth mentioning for this community: I use Claude Code extensively to develop HQL, particularly for the Rust implementation, tests, and integration work. I spend a lot of time on the actual language design, syntax, type system, and architecture, while AI assisted coding helps me implement and iterate much faster.

Version 0.7.1 focuses on modularity, including selective imports, aliases, receiver functions, and custom Rust extensions that can be installed as packages. So one can define a body-less function in HQL, and implement/deliver it in Rust.

There's also HyperMarkDown, a VS Code extension that turns Markdown into interactive notebooks with executable HQL cells.

Links:

There's quite a lot to play with now. I've written an HQL book, and there are executable Docker Compose demos covering Kafka, PostgreSQL, NATS, Spark, Delta Lake, MinIO, transactions, and cryptography.

Super happy about feedback.


r/AIprogrammingLanguage • • 2d ago

Leksika

Thumbnail
github.com
4 Upvotes

Only russian coding language, no special symbols (only !?() ), Ai playground, and case based coding.


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 • • 15d ago

Update on the Oak framework for web apps and more

Thumbnail
reddit.com
4 Upvotes

r/AIprogrammingLanguage • • 23d ago

madc v0.106.1 released โ€” faster C compilation, leaner executables, SQLite support, and improved C++ exceptions

4 Upvotes

I've released madc v0.106.1, with improvements to compilation speed, native executable dependencies, C and C++ compatibility, and modularity.

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 an installed development toolchain.

What's new

  • C compilation is approximately 1.8ร— faster than v0.105.0 across 40 measured compilation workloads. C++ compilation has also improved modestly.

  • Leaner native executables โ€” madc now links only the libraries a program actually needs, eliminating unnecessary dependencies on libmadc, libstdc++, and other runtime libraries for plain C programs. A C hello-world executable is just 10 KB on Linux and depends only on libc.

  • SQLite now builds and runs its tests โ€” SQLite 3.54.0's test fixture passes 394,058 of 394,060 tests, matching the results from GCC and Clang.

  • Improved C++ exception handling โ€” exceptions now use native platform unwinding, correctly destroying objects as the stack unwinds.

  • Better C++ compatibility โ€” improvements to templates, type traits, virtual function dispatch, object lifetimes, and constructors.

  • Modular architecture โ€” Git, Markdown, and web UI functionality can now be loaded as independent modules using statements such as import git;.

  • Improved GCC command-line compatibility โ€” response files, multiple source files, additional compiler flags, and more helpful diagnostics.

  • Improved generated-code performance โ€” approximately 2% faster than v0.105.0 across the measured benchmark suite.

A notable compile speed comparison

The SQLite amalgamation compiles at -O2 in:

CompilerTime
madc3.2 s
GCC16.8 s
Clang15.7 s

These are results for this workload, not a claim that madc universally outperforms GCC or Clang.

Updated companion project releases:

  • madcide v0.9.1 โ€” the extensible terminal and desktop IDE.

  • Chthonia v0.3.1 โ€” the Thonny-inspired C/C++ learning environment built on madcide.

(Both include madc v0.106.1).

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

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


r/AIprogrammingLanguage • • 26d ago

October update

Thumbnail
reddit.com
4 Upvotes

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 13 '26

Klyn 0.2.0

Post image
3 Upvotes

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 • • Oct 12 '26

madc v0.104.0 released โ€” interactive editing, LSP/MCP support, and madcide gets its own repo

4 Upvotes

I've released madc v0.104.0, a fairly substantial update that also completes the separation of madc and madcide into independent projects.

What's new in madc

  • Expanded interactive REPL โ€” madc -i now includes an ed/ex-style editing mode, multiple file buffers, undo/redo, search and replace, and syntax highlighting.

  • New REPL commands โ€” inspect source definitions, check code without running it, manage projects, rebuild interactive sessions, and work with command history.

  • Built-in Language Server (LSP) โ€” diagnostics, symbols, definitions, references, hover information and semantic highlighting, available to external editors.

  • Built-in MCP server โ€” exposes compiler-aware code analysis, editing operations and project memory to AI coding tools.

  • Better regular expressions โ€” unified PCRE2 support across Linux, Windows and macOS.

  • Automatic language selection โ€” .c files default to C17, .cpp files to C++17, and .mad files to the madc dialect. Explicit --std options still override these defaults.

The madcide split

madcide now has its own repository and independent releases.

Starting with this version, madc is distributed without madcide. The IDE is available separately as madcide v0.7.0, built using madc v0.104.0.

Chthonia v0.1.0, the beginner-friendly C/C++ environment inspired by Thonny, builds on madcide and madc.

The three projects now have distinct roles:

  • madc โ€” compiler, language, REPL and development services.

  • madcide โ€” extensible terminal (TUI) and desktop (GUI) IDE.

  • Chthonia โ€” beginner-friendly C/C++ learning environment built on madcide.

Low friction C and C++ without the ceremony.

Repositories:


r/AIprogrammingLanguage • • Oct 12 '26

How should an Objective-C-inspired language decide which new constructs use an @ prefix?

3 Upvotes

Background

I'm designing a statically compiled programming language called Jeti. Its syntax is inspired by Objective-C, and its compiler translates Jeti source code into C99 before compiling it with Clang.

One of my design goals is to preserve Objective-C's recognizable syntax while introducing modern language features. I also want Jeti to remain a strict superset of C99, so existing C identifiers should ideally remain valid in Jeti code.

I'm currently unsure how to decide which new language features should use an @ prefix and which should use ordinary keywords.

Current syntax

Jeti retains several Objective-C constructs:

  • @ interface and @implementation for class declarations and implementations.

  • @ property for properties.

  • @ protocol for protocols.

  • @ selector for selectors.

  • @ try, @ catch, @ finally, and @ throw for exception handling.

  • @ autoreleasepool for autorelease pool management.

It also introduces new features with different syntax conventions:

  • async appears in return-type positions, as in - (async int)fetchUser:(int)uid;.

  • await is a prefix operator, as in await [self fetchUser:uid].

  • @ throws(NPString *) declares the exception types a method may throw.

  • @ defer { ... } introduces deferred execution.

  • @ namespace, @ using, and @ endnamespace provide namespace-related functionality.

  • @ noarc { ... } marks a region where ARC is disabled.

  • Pattern matching extends case with forms such as case NPString *s: and case > 100:.

  • Generic types use forms such as Box<NPString *>, with constraints such as T : Proto.

This leaves me with a mixture of ordinary keywords and @-prefixed constructs.

A possible design principle

One possible principle is to distinguish features by their grammatical role.

Features that occupy existing grammatical positions could use ordinary keywords. For example, async modifies a method's return type, while await acts as an expression operator.

Features that introduce new language constructs could use the @ prefix. For example, @ defer introduces a new statement-like construct, and @ namespace introduces a new declaration construct.

However, I'm not sure whether this is a meaningful and consistent distinction or merely an arbitrary convention.

Three possible designs

Design A: Keep the current mixture

Use async and await without @, but retain @ throws.

For example, a method declaration would use - (async int)fetchUser:(int)uid @ throws(NPString *);, and an asynchronous call would use await [self fetchUser:uid].

The advantage is that async fits naturally into the return-type position, and await reads naturally as an expression operator. However, @ throws looks inconsistent with the other two features, even though all three belong to the same general family of asynchronous and error-handling functionality.

Design B: Use ordinary keywords for all three

Use async, await, and throws without @.

For example, the method declaration would be - (async int)fetchUser:(int)uid throws(NPString *);, and the asynchronous call would be await [self fetchUser:uid].

This provides consistent spelling for the three features, but it raises questions about how they fit into Objective-C-inspired syntax and whether they conflict with existing C identifiers.

Design C: Use the @ prefix for all three

Use @ async, @ await, and @throws.

For example, the method declaration would be - (@async int)fetchUser:(int)uid @ throws(NPString *);, and the asynchronous call would be @ await [self fetchUser:uid].

This gives the three features a consistent visual convention and avoids treating their names as ordinary C keywords. However, @ async in a return-type position looks unusual, and @ await as a general expression operator may feel less natural than @await.

C99 compatibility

The C99 compatibility requirement complicates this decision.

If @async, @await, or @throws becomes a reserved keyword, existing C code that uses one of those words as an identifier may no longer be valid Jeti code. Using @async, @await, and @throws avoids that particular conflict because the @ prefix distinguishes these tokens from ordinary C identifiers.

On the other hand, requiring the @ prefix for every new feature may make the syntax less natural, especially when a feature occupies an established grammatical position.

It may also be possible to use context-sensitive parsing or another mechanism to preserve existing C identifiers, but I'm not sure whether that would be a good language-design choice.

Questions

  1. Is there a principled reason to distinguish new features by grammatical role, using ordinary keywords for features that fit existing grammatical positions and @ prefixes for features that introduce new constructs? Or is this distinction too arbitrary to be useful?

  2. Should related features use the same spelling convention? In particular, should async, await, and throws all use the @ prefix for consistency with one another and with Objective-C's existing exception-handling constructs, or is it reasonable to treat them differently based on their grammatical roles?

  3. Are there useful precedents in Objective-C or other languages for deciding when a language extension should introduce a new keyword versus a specially prefixed construct? I'm particularly interested in examples involving new statement or expression syntax, rather than declaration annotations or attributes.

  4. What is the best way to preserve strict C99 compatibility while adding features such as asynchronous functions and exception specifications? Would prefixed forms such as @async, @await, and @throws be preferable to ordinary keywords, or would context-sensitive parsing be a better solution?

I'm interested in both the consistency of the language's syntax and the practical consequences for parsing, compatibility, and readability.

Iโ€™d especially appreciate input from experienced Objective-C developers, particularly those who are also familiar with a modern high-level language that supports async/await. ๐Ÿ™

Jetiโ€™s source code and development are available on GitHub: https://github.com/3shine123/jeti-lang


r/AIprogrammingLanguage • • Oct 11 '26

Working on madc's next release (v0.104.0)

4 Upvotes

I'm currently working on madc's upcoming release which should hopefully be ready sometime later today, but wanted to discuss it a bit here before the release announcement.

As you may know, I built an IDE in madc (called madcide), and I also built a plugin to make madcide look, feel, and behave much like Thonny (the learning IDE for Python), and made it its own standalone app with its own repo named Chthonia.

That made me realize that madcide should also really be in its own repo, since it grew to be far more than a sample application.

Thus, the next release of madc will be split into three releases:

  • madc v0.104.0

  • madcide v0.7.0

  • chthonia v0.1.0

That is not all that this release will do, however (the split), there has been some functionality shuffling, decisions on what should exist where, with some bug fixes along the way, of course.

So what I would like to discuss here was more along the lines of the language itself, and asking for feedback from other fellow language developers...

So, as you may also know, I've added a REPL to madc (as of v0.101.0), which was inspired by various existing REPL implementations (since there is not yet a firm standard for C/C++), so I took some inspiration from Julia, IPython, Cling and clang-repl, and supported multiple command sets as aliases to each other to make it easier for those already used to one form or another.

What I'm bringing in with version 0.104.0, is the full set of the vifamily of line editing tools ("colon mode"), which originates from the lineage of ex and ed. This will only really be familiar with people who use vi, vim, or neovim.

For a brief history lesson, ed was written in C by Ken Thompson (author of B language, predecessor to C language) in 1973, ex was an extended version of ed, written by Bill Joy between 1976-1977, who also wrote vi (the "visual" mode of ex). All of these technologies (including C) were part of UNIX, and why you are always pretty much guaranteed to have access to vi under any sort of UNIX-like operating system. Bram Moolenaar wrote vim as a successor to vi in 1992, and most flavours of UNIX (including Linux) actually ship with vim, and typing vi will launch vim.

Personally, I am not a vi/vim/neovim user, but millions of people are familiar with it, and it does have a very powerful command line mode, and this will now be part of the madc REPL mode.

I'm also bringing in the LSP and MCP server support and most of what was headless and line-mode of madcide into madc itself, so that madcide will primarily be only the visual (TUI / GUI) parts.

The reasoning for this is that these are all non-GUI things, and they are fairly small, and make madc itself more powerful it its core, and that these things could be more foundational for applications outside of madcide.

Madcide started out as an exercise for developing madc's UI module, which allows for having the same UI elements across multiple UI modes -- line mode, TUI mode, GUI mode, etc. It's written in madc, and it is designed to be very flexible, modular, and you can write plugins for it in madc -- Chthonia is a madcide plugin, but as madc is both a JIT and an AOT language, Chthonia is available as a full on compiled standalone application, compiling the chthonia plugin into a binary linked against libmadc and libmadcide.

I'm also putting more effort into segregating add-on functionality into modules -- especially if they add a third party library dependency. An example of this is git support.

I know this is a lot of reading, but hoping for some interesting discussion here as I think it encompasses programming language development in general, and is not specific to madc.

So, what do you think of this split? Does anyone here use REPL mode in other languages? Do you plan a REPL mode for your language?


r/AIprogrammingLanguage • • Oct 09 '26

madc v0.103.0 released โ€” faster compilation, improved C++ compatibility, and a major TUI facelift

Post image
4 Upvotes

I've released madc v0.103.0, with improvements to both the compiler and its accompanying IDE, madcide.

What's new in madc

  • Faster compilation โ€” improvements to string interning and header processing should make compilation roughly 20% faster, depending on the workload.

  • Improved C++ compatibility โ€” continued progress on standards conformance, with C++11 compliance now reaching 77.3% in the GCC test suite.

  • Reliability improvements โ€” fixes to var string handling, memory safety, and additional sanitizer testing.

  • REPL enhancements (since v0.101.0) โ€” %run, %call, $build, %open, .load, .type, .help, .quit, and much more

What's new in madcide

  • Major terminal UI facelift โ€” the TUI now resembles the desktop GUI, with menus, toolbar, editor tabs, line numbers, framed panes, floating dialogs, and VS Code Dark+ styling.

  • Full mouse support โ€” navigate menus, select text, place the cursor, and interact with the editor using the mouse.

  • Improved integrated terminal โ€” supports ANSI formatting, 256 colours, and true 24-bit colour.

  • Multiple files on startup โ€” madcide a.c b.c c.c opens all three files in separate tabs.

  • Integrated documentation โ€” help pages open directly in the editor, with a browsable Help Index in the sidebar.

  • GIT support โ€” some basic read-only (for now) git functionality now exposed through the IDE menus and also the REPL mode inside the IDE through %git

Project updates

Since my previous announcement, Chthonia has moved into its own repository, with v0.0.3 released separately:

https://github.com/derekbsnider/chthonia

This will also be the last madc release with madcide included in the madc source repository. Starting with the next release, madcide will move into its own repository as well.

The plan is to keep the three projects independently maintained, but bundled together for convenience:

  • madc โ€” the compiler and language.

  • madcide โ€” the IDE, distributed with madc included.

  • chthonia โ€” the C/C++ learning environment, distributed with both madcide and madc included.

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


r/AIprogrammingLanguage • • Oct 08 '26

The Unfair Benchmark: What is your language unfairly good at?

2 Upvotes

I'm thinking about a small community challenge for experimental, new, and AI-driven programming languages.

The idea is simple:

Every language gets to choose its superpower.

ยซWhat is your language unfairly good at?ยป

A few superpowers I had in mind:

- Runtime performance

- Memory efficiency

- Code density / expressiveness

- Build / compilation speed

- Parallelism / concurrency

- Compile-time computation

- Preventing errors before runtime โ€” e.g. formal verification, proofs, dependent types, contracts

- Metaprogramming

- Hardware / SIMD / GPU utilization

- Developer feedback loop

- Something completely different?

But I don't want to define the categories all by myself.

This is the first step of the game: choose your language's superpower.

Tell me what you think your language is exceptionally good at โ€” even if it doesn't fit any of the categories above.

How we measure it comes later. We can figure that out together.

Right now, I'm much more interested in hearing what you believe your language can do unusually well.

P.S. to the non-AI languages: Don't worry, you're allowed to play too. We believe in inclusion. ๐Ÿ˜‰

And yes, you're absolutely encouraged to use AI to code the benchmark. ;-)

So: What's your language's superpower?


r/AIprogrammingLanguage • • Oct 08 '26

If you're not building with your language, it probably doesn't work the way you think it works

4 Upvotes

Hey everyone,

I've been building Sharpy ( https://github.com/antonsynd/sharpy ) for over a year now (wow time flies, and so does technology). I admit, even with AI, I haven't gotten as far along as I had planned (still far from 1.0). The major thing I spend my time on is fixing bugs. Occasionally, I have to convince Fable/Opus to let me do the fun stuff (new syntax, etc.).

Anyway, with the recent uptick in AI-driven game development, recomps, decomps, you name it, I decided I'd try my hand at having Claude vibe code a game for me. After trying it out (2-shot, with three.js https://github.com/antonsynd/zero ), I decided to dogfood my own language in Unity.

Some history, I started Sharpy because I didn't want to code in C# to make a Unity game. Honestly, in the time it took me to build Sharpy, I could've learned C# and had actually made the game in that time (I think).

Anyway, I let Opus build out a slice of Pokemon Heart Gold Soul Silver here: https://github.com/antonsynd/pokemon-sharpy with the help of a Unity plugin tailored for Sharpy https://github.com/antonsynd/sharpy-unity .

I quickly learned that I had even more bugs to add to my backlog. Some are related to how Sharpy resolves symbol names (it mangles Pythonic snake_case to C# PascalCase for interop), some are related to drift in compiler options (single file vs. project), etc. As such, Claude had to find workarounds, and I made it create an ideal version of the source code as the goalpost that we'll eventually reach.

Anywho, while I think it's cool to 1-shot or X-shot a language, the real tests come from the typical actions: self-hosting being one of the big ones, and dogfooding.

Curious to see how other people find bugs in their languages. I also hear that a trendy thing these days is to formalize your implementation or language and use a theorem/proof solver to verify the implementation, like using Verus, LEAP, or TLA+.


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 04 '26

Updated homepage and roadmap for Monad

4 Upvotes

I recently updated the homepage of Monad to give a better overview. There are still plenty of bugs and missing features. I will open for contributions once the core design is more stable. For now, testing and giving feedback is useful.
https://monad-lang.org/


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 02 '26

Nikaia: a pre-alpha language where the compiler figures out the "how". How would you like to experiment with it?

4 Upvotes

Hi all,

I've been building Nikaia, a pre-alpha language that compiles to Rust.

The basic idea is simple: in a lot of systems code, you end up specifying how memory, waiting, sharing, etc. should work rather than just describing what you want the program to do. Nikaia tries to have the compiler figure out those details for you.

So thereโ€™s no async/await, GC, or manual memory management. Data races, missing values and unhandled errors are compile-time errors, with plain-language hints about what to do instead.

It's still very early, but it can already build real programs: a JSON parser, a log analyser, a small HTTP server, the One Billion Row Challenge, and more.

Nikaia itself is built almost entirely by AI agents, and they're currently rewriting the compiler in Nikaia (self-hosting). So the language is getting quite a bit of real-world use already.

I'd love to have people try it and tell me what makes sense, what doesn't, and where the language gets in the way. "This can't work because..." is just as useful as praise.

What would make that easy for you?

- Is the repo enough?

- A crate you can "cargo install"?

- A prebuilt executable?

- A Docker image with everything set up?

- An LSP / IDE integration?

Repo: https://github.com/Nikaia-Language/Nikaia

Docs: https://nikaia-lang.org/


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 30 '26

declint - make your own custom lint rules in YAML

4 Upvotes

declint (docs) is a tool for making your own lint rules in YAML โ€” the house rules that stock linters will never ship.

For instance: your AI model added except Exception: pass, and you want to know whenever that happens:

rules:
  - id: except-pass
    pattern: 'except Exception:\\s\*pass'
    severity: warning
    message: 'swallowed exception'

Rules are just regex and a message. When a regex can't express the check, there's a Lua escape hatch โ€” vetoes, whole-file analysis, absence rules ("every Dockerfile needs a HEALTHCHECK").

Rules run in your CI (inline PR annotations via --format github) and in your editor through LSP (declint.nvim for Neovim). Every rule can carry embedded fixtures, and declint test runs them โ€” so AI-written rules come with their own spec.

Install: cargo install declint. Ships with presets (Python, INI, Markdown, shell, Dockerfile, TOML, JSON, JS) and community rulesets you can pull with one line. Feedback welcome, especially brutal takes on the YAML format.