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

Project links:

• 🌐 Website: https://protos.guillermomolina.com
• 💻 Source code: https://github.com/guillermomolina/protos
• 📚 Public engineering record / decisions / evidence: https://github.com/guillermomolina/protos-project-docs
• 🗂️ Development project: https://github.com/users/guillermomolina/projects/1

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.

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? 😄

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

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.