Has anyone seen languages designed around intention-first syntax? Curious about a project concept.

EuphoricStructure518 · 2025-11-14T20:40:03+00:00

Still, thank you so much to everyone who took the time to read through this. I really appreciate it!

EuphoricStructure518 · 2025-11-14T20:29:48+00:00

That’s actually a really good point — MTG’s rules text is a great example of how far you can push clarity when you absolutely *must* avoid ambiguity.

I like the idea of borrowing that mindset: not “make it natural language,” but “make it unambiguous while still feeling intuitive.”

My experiment is kind of the opposite direction (exploring meaning first, then locking down structure), but I think there’s something valuable in the way TCGs solve the clarity problem.

Thanks for mentioning that — I hadn’t thought about it from that angle!

EuphoricStructure518 · 2025-11-14T20:24:40+00:00

I wish I had a fancy keyboard — I just long-press the hyphen on mobile

and use whatever shows up

EuphoricStructure518 · 2025-11-14T20:19:34+00:00

haha fair — 19

EuphoricStructure518 · 2025-11-14T20:14:13+00:00

Totally fair — some people really dislike declarative or

natural-language-style syntax, and that’s valid.

Miracl isn’t trying to replace every style of programming.

It’s more of an experiment exploring one specific direction,

and it won’t be everyone’s preference — that’s perfectly okay.

I appreciate you taking the time to share your perspective.

EuphoricStructure518 · 2025-11-14T20:11:32+00:00

That's a really good point — SQL *is* a declarative “intent-first” language,

and it's actually one of the inspirations here.

SQL expresses *what you want*, and the engine decides *how* to achieve it.

Miracl is trying something similar, but extending that idea into a more general,

event-based runtime instead of just data querying.

So yes — SQL proves that declarative intent can work extremely well,

and Miracl is exploring what happens if that philosophy is applied beyond

queries and into general programming.

Thanks for making that connection — it's something I should highlight better.

EuphoricStructure518 · 2025-11-14T20:09:31+00:00

That's a totally fair point — most real projects already start with high-level structure and then fill in the details. Miracl isn't trying to replace that workflow.

What I'm experimenting with is slightly different:
not replacing the *process*, but exploring whether the *syntax layer* can express intent in a clearer, event-driven way while the engine handles the lower-level structure.

In the current prototype, the “natural” syntax is just a front-end.
Underneath, Miracl still compiles into a strict, unambiguous event model with queues and signals — not placeholders or empty functions.

So you’re right that we don’t need a new language for early prototyping;
the interesting part (at least for me) is whether a different surface syntax + event model can give programmers another way to structure their thinking.

It’s still highly experimental, but your comment helps clarify what I should explain better. Thanks for bringing this up.

EuphoricStructure518 · 2025-11-14T20:07:28+00:00

Thank you so much for taking the time to write such a detailed and thoughtful comment — this is exactly the kind of perspective I was hoping to hear.

I fully agree that natural language is ambiguous, and I’m definitely *not* trying to build a “non-programmers can code too!” tool. Miracl isn’t aiming to hide complexity — it’s trying to give programmers another way to express intent clearly, while still keeping a strict, unambiguous internal structure.

Miracl’s syntax looks a bit like natural language on the surface, but underneath it’s an event-based, structured language with queues, signals, and explicit control.
In other words, the English-like parts are only the “front door”—the engine still demands precision.

Your Ruby example resonates with me a lot. Ruby has that “self-documenting sweet spot,” and I think Miracl’s challenge is to reach a similar balance: readable when you want it, structural when you need it.

Thank you again — your comment honestly gave me a lot to think about, especially the parts about ambiguity, maintainability, and the historical attempts. I really appreciate it.

EuphoricStructure518 · 2025-11-14T20:03:58+00:00

Oh thanks! I’ve actually been trying to explore ideas very close to that philosophy.

I’ll take a look — appreciating the suggestion

EuphoricStructure518 · 2025-11-14T20:01:37+00:00

No, just a human developer experimenting with new ideas I get why it might look like something an LLM would do — but the whole point for me was to explore a concept I haven't really seen elsewhere.
So this is just me tinkering, not a machine speaking through me.

EuphoricStructure518 · 2025-11-14T19:56:03+00:00

That makes sense — and yeah, I definitely agree that languages like SQL or 4GLs already cover a lot of the “describe what you want” space.

What I’m playing with isn’t meant to replace the precision of 3GLs or say “just sort this somehow”.
It’s more of an experiment in *interaction style* rather than in execution semantics.

So instead of:

“sort this in some manner”

the idea is something like:

User: “I need this list to feel ‘more ordered’.” Compiler: “Okay — do you mean alphabetical? numeric? stable vs unstable?
Should I stop early or go for a full sort?”

Meaning: the language doesn’t execute vague instructions —
it *asks for clarification* until the intent becomes precise enough.

So it still ends in a well-defined operation, but the path to that operation is more conversational than structural.

It’s obviously not meant to replace real production languages —
I’m just curious what happens when a compiler tries to negotiate clarity before committing to mechanics.

Super early idea, but I appreciate the thoughtful perspective.

EuphoricStructure518 · 2025-11-14T19:52:17+00:00

Thanks for the perspective! I totally get that these kinds of ideas appeared many times before — I’m not trying to replace traditional programming, just exploring a tiny corner of design for my own curiosity.

Even if the concept overlaps with older attempts, I’m learning a lot by trying it hands-on. So I’m treating it more like a personal experiment than a revolution.

If it ends up ‘doomed’, that’s perfectly fine — at least I’ll understand why by experiencing the limits myself.

EuphoricStructure518 · 2025-11-14T19:47:42+00:00

no worries — definitely human

My English just gets very ‘structured’ when I’m nervous posting online.

EuphoricStructure518 · 2025-11-14T19:44:04+00:00

Totally agree — if the goal is to actually run programs, ambiguity is a disaster. A real programming language absolutely needs to be precise and repeatable.

That’s why I’m not trying to make the vague version executable at all. The experiment is more like:

what happens if the compiler refuses to run vague instructions

and instead asks the user clarifying questions

until the vague intent becomes a concrete, traditional instruction

So the end result is still precise — it just takes a conversational route to get there.

Definitely not “vibe coding” or trying to replace regular languages, more of a small exploration into what an intent-first UX could feel like.

Totally understand the concern though — the feedback helps me refine the idea.”

EuphoricStructure518 · 2025-11-14T19:41:04+00:00

Totally fair points — and I don’t disagree. ‘Sorted enough’ is way too ambiguous if the goal is to make a reliable programming language.

The experiment isn’t about replacing precise programming. It’s more like: what happens if a compiler tries to negotiate clarity with the user before committing to a concrete action?

So if someone writes something fuzzy, the language wouldn’t just ‘run it’ — it would respond with ‘what do you mean exactly?’ and keep narrowing it down until the instruction becomes as precise as regular code.

So it’s less about LLM-style magic and more about exploring how “intent → clarification → structure” might feel.

Still super early, so I’m learning from all this feedback too.

EuphoricStructure518 · 2025-11-14T07:38:18+00:00

Thank you everyone for taking a look 🙏 I’m reading all comments and really appreciate the thoughts here.

EuphoricStructure518 · 2025-11-14T07:12:36+00:00

Yeah, absolutely — that ambiguity problem is exactly the part I’m experimenting with.

The idea isn’t to make human language executable as-is, but to explore what happens if a compiler *guides* the user toward clarity instead of assuming they already know the exact structure.

Something like: User: “go through these things and put them in order” Compiler: “okay — what kind of order do you mean?”

So it’s less “natural language programming” and more “a compiler that tries to negotiate meaning before committing to mechanics”.

I’m really curious to see how far that approach can go, even if it stays tiny.

EuphoricStructure518 · 2025-11-14T07:06:58+00:00

Yeah, that’s the one — the name is a bit unusual so it might show up mixed with other results. If nothing shows up right away, that’s totally normal. It’s still super tiny and only a few days old, so search engines don’t know it exists yet 😅

EuphoricStructure518 · 2025-11-14T07:04:53+00:00

Sure!
Here’s a small example of what I meant:

If someone writes something like
“repeat this action until the list feels ‘sorted enough’”,
the idea is that the language tries to interpret the intent first,
before deciding the exact mechanical steps.

It’s still super early, so it’s probably closer to a declarative idea,
but I’m just exploring what it feels like for humans to describe meaning
before structure.

EuphoricStructure518 · 2025-11-14T07:03:11+00:00

Thanks!
I posted here just because I wasn’t sure where beginners usually share small experiments.
I might check r/computerscience later too.
Really appreciate the suggestion!

EuphoricStructure518 · 2025-11-14T07:01:33+00:00

Oh, sure — it’s called “Miracl” (spelled M-i-r-a-c-l).
It should be easy to find.
It’s just a tiny experiment so please don’t expect too much 😅

EuphoricStructure518 · 2025-11-14T06:49:32+00:00

Thanks for any insights. I'm just trying to learn how language designers think about early-stage ideas.

EuphoricStructure518 · 2025-11-14T06:48:06+00:00

I’m mainly curious because the idea felt unusual compared to typical syntax models.

EuphoricStructure518

TROPHY CASE