hckrnws

Would recommend placing example language syntax above the fold. Was tough to have to scroll halfway down the entire site to see any syntax. Nobody cares about the EBNF syntax until they have a feel for the language.

Last commit is from 2 years

Alt opinion: syntax is the least important part of a programming language. I can't wait for the day someone invents one where it's defined entirely as an AST (with the S standing for Semantic). Just bring your own weird syntax.

I guess Unison is the closest to this platonic ideal right now? https://github.com/unisonweb/unison/issues/499

I have an idea, maybe we could represent that AST as parenthesis.

That's cool, but I might prefer semantic whitespace. Sure would be neat if we could both work with the same code in our preferred forms.

Like this? https://en.wikipedia.org/wiki/Whitespace_(programming_langua...

Ah yes, now there is a LISP I can get behind!

Honestly, we can do better than LISPs.

Just use curly brackets and boom. LISP 3k.

You're welcome.

It can even be used to represent serialized objects...

Love this take! Unison is exactly this, and it's awesome!

Here's a quote from one of the creators:

> But here's the super cool thing about our language! Since we don't store your code in a text/source code representation, and instead as a typechecked AST, we have the freedom to change the surface syntax of the language very easily, which is something we've done several times in the past. We have this unique possibility that other languages don't have, in that we could have more than one "surface syntax" for the language. We could have our current syntax, but also a javascript-like syntax, or a python-like syntax.

https://news.ycombinator.com/item?id=46053304

Can Raku do something like this? I was lightly exploring it recently, and I thought I saw that something like this may be possible with it.

I'm not super familiar with Raku, but if RakuAST is what you had in mind it looks a bit different:

    use experimental :rakuast;
    
    my $ast = RakuAST::Call::Name.new(
      name => RakuAST::Name.from-identifier("say"),
      args => RakuAST::ArgList.new(
        RakuAST::StrLiteral.new("Hello world")
      )
    );

Edit: I should have looked deeper, `DEPARSE` does exactly this:

https://docs.raku.org/type/RakuAST

Neat!

It also goes from source code to AST:

  $ raku -e 'say Q|say "Hello World!"|.AST'
  RakuAST::StatementList.new(
    RakuAST::Statement::Expression.new(
      expression => RakuAST::Call::Name::WithoutParentheses.new(
        name => RakuAST::Name.from-identifier("say"),
        args => RakuAST::ArgList.new(
          RakuAST::QuotedString.new(
            segments   => (
              RakuAST::StrLiteral.new("Hello World!"),
            )
          )
        )
      )
    )
  )

I completely agree: If it is ugly-as-sin-but-useful I will learn it.

The aesthetic of mathematics as it appears in journals is I think questionable, but undeniably convenient for communication, so it is every language making the case that you (dear reader) can say something very complicated and useful in the ideal amount of space.

"Hello world" isn't that: That's the one program everyone should be able to write correctly, 100% of the time. That's how we can talk about brainfuck as exercise, but APL is serious.

Or put another way, even if seeing a new kind of "hello world" excites dear reader, it's probably not going to excite me, unless it's objectively disgusting.

What Om does here is exactly right for me: It tells me what it is, and makes it easy for me to drill down to each of those things to figure out what the author means by that, and decide if I am convinced.

I mean, that's the point right? I'm here trying to learn something new and that requires I allow myself to be convinced, and since "hello world" is table-stakes, seeing it can only slow my ability to be convinced.

This is a Very Bad Idea. Two people working with the same language will be unable to reason about each other's code, because it requires understanding their bespoke syntax and its nuances.

No it won't? That's exactly the point -- each of those people will be viewing the code in their own preferred syntax. If there is semantic nuance in the writer's syntax, the reader will see it presented in the best way their preferred syntax's representation can provide.

Imagine all the hours saved that are currently spent on tired tabs vs spaces debates, or manicuring .prettierrc, etc etc. The color of the bike shed might matter (sometimes a lot) to some people, I know, but it's storing bikes away from the elements and thieves that is the goal, not obsessing over optimizing something that is demonstrably a subjective matter of taste.

Those are both formatting examples though? You're suggesting totally different syntaxes, which means you can't even point to the same line in a codebase when talking about a PR. This throws up massive hurdles around communication when you could just agree on one standard and move on.

  class Bean {
    private boolean sprouted;

    public void sprout() {
      this.sprouted = true;
      // ...
    }
  }

  data Bean = Dormant | Sprouted
  
  sprout :: Bean -> Bean
  sprout Dormant = Sprouted
  sprout Sprouted = -- aw, beans, we could have modeled
                    -- this state as impossible to construct,
                    -- but you chose runtime checks, so
                    -- here we are.

Aren't LLMs supposed to write machine code directly, no more programming languages at all, any day now? Joking aside, programming languages are a good mental exercise. Forth was my first language after assembly. Didn't like the stack juggling and ended up using its macro assembler more and more, it became something else, conventions over code I suppose, like what to keep in registers. Forth (and Unix) got the composability requirement right, the testing of individual units.

So instead of using programming languages designed specifically to effectively express algorithms and data structures, we are going to use natural language like English that is clearly not expressive enough for this? It’s like rewriting a paper about sheaf cohomology in plain English without any mathematical notation and expecting it to be accessible to everyone.

:) Not exactly. We'll use English to get a kinda description, then test and debug to make that functional, then cycling the functionality with users to nail down what is actually needed. Which won't be written down anywhere. Like before. Except with autocomplete that tries to predict a page or two of code at a time. Often pretty accurately.

I do not think you are saying same thing here :). No one doubts we can put "make a todo app" into english, and that you can yeah test with users. But that's different from a task which would articulate, in only english, the precise layout and architecture of the MVC that make the app possible.

English is fine, but I am personally a lot faster in my mind and fingers and IDE with a language suited for this stuff. AI guys just want to be teachers deep down I think :).

Conrad Barski, Feb 25, 2026:

> Working atari 2600 flappy bird, by just asking chatgpt to directly output the raw bytes for a cartridge image

TBH this is a bit unexpected: it should know how to encode instructions, of course, but calculating all jumps on the fly is rather hard (I think).

I'm still waiting to see the first show HN I made a language designed for LLMs to write programs better.

A few days ago I asked Claude what kind of language it would like to program in, and it said something like Forth but with static typing, contracts, and constraint solving, implemented on the Erlang BEAM.

So I have been prodding Claude Code for a few sessions to actually do it. It's a silly experiment, but fun to watch. Right now it's implementing a JSON parser in the generated language as a kind of milestone example.

This is one of the more interesting uses of Claude I've seen. Instead of asking it to write code in an existing language, you asked it to design the language it wants to think in. There's something philosophically fun about that I feel = like asking a painter to design their ideal brush.

I'm curious whether the generated language actually makes Claude produce better/more reliable outputs when writing in it, or if it just reflects Claude's training bias toward what "good language design" looks like in its corpus. Would be a fascinating benchmark to run.

If you want to go really meta ask Claude Code to re-implement itself in the new language. You could keep going doing this.

It kind of feels like it wants to go there or thereabouts, but to be honest, I just half understand half of the roadmap it has written for itself:

  - **v0.0.1** (complete): Interpreter, PRE/POST contracts, REPL, TIMES/WHILE, FILTER/MAP/REDUCE, strings, I/O
  - **v0.1.0** (complete): Static type checker, VERIFY (property-based contract testing), maps, Safe Bank milestone
  - **v0.2.0** (complete): PROVE — compile-time contract verification via Z3 SMT solver
  - **v0.3.0** (complete): Algebraic data types (TYPE/MATCH) — Option, Result, and user-defined sum types with exhaustiveness checking
  - **v0.4.0** (complete): JSON parser/encoder milestone — wildcard MATCH, string primitives, ROT4, PAIRS, NUM_STR, VERIFY for sum types
  - **v0.4.1** (current): PROVE for IF/ELSE branches (via SMT-LIB `ite`), ABS/MIN/MAX, function call inlining
  - **v0.5.0** (next): Practical language features — LET bindings, IMPORT/modules, error handling, standard library
  - **v0.6.0**: PROVE for MATCH/algebraic types, refinement-style reasoning
  - **v0.7.0**: Typed BEAM concurrency (typed message passing, stateful actors)
  - **v0.8.0**: BEAM bytecode compilation
  - **Future**: Declarative constraint solving, tensor/distribution primitives, multi-agent collaboration

I plan to keep dumping tokens into it here and there to see where it goes, it's a fun rabbit hole.

I find that it's able to produce working code in the generated language just from the README and the previous examples without much trouble. And I've seen the strict typing help it catch and correct bugs quickly. I steer it very little. The only thing I keep an eye on is not allowing it to cheat about things like writing lots of concrete functionality in the host language and then just calling that from the interpreter.

> There's something philosophically fun about that I feel = like asking a painter to design their ideal brush.

With the large difference that painters actually paint and use the brush, they don't just algorithmically regurgitate paintings they've been shown.

If you don't mind, could you drop some code? I'd be interested to see the result :)

sure, for example it generated this small demo of the type and contract safeguards. As you can see, it's mostly "Forth but with things":

  # bank.ax — The Safe Bank (Milestone 2)
  #
  # Demonstrates property-based verification of financial operations.
  # Each function has PRE/POST contracts. VERIFY auto-generates random
  # inputs, filters by PRE, runs the function, and checks POST holds.
  
  # DEPOSIT: add amount to balance
  # Stack: [amount, balance] (amount on top)
  # PRE: amount > 0 AND balance >= 0
  # POST: result >= 0
  DEF deposit : int int -> int
    PRE { OVER 0 GTE SWAP 0 GT AND }
    ADD
    POST DUP 0 GTE
  END
  
  # WITHDRAW: subtract amount from balance
  # Stack: [amount, balance] (amount on top)
  # PRE: amount > 0 AND balance >= amount
  # POST: result >= 0
  DEF withdraw : int int -> int
    PRE { OVER OVER GTE SWAP 0 GT AND }
    SUB
    POST DUP 0 GTE
  END
  
  # Verify both functions — 500 random tests each
  VERIFY deposit 500
  VERIFY withdraw 500
  
  # Prove both functions — mathematically, for ALL inputs
  PROVE deposit
  PROVE withdraw
  
  # Demo: manual operations
  1000 200 deposit SAY
  1000 300 withdraw SAY

  VERIFY deposit: OK — 500 tests passed (1056 skipped by PRE)
  VERIFY withdraw: OK — 500 tests passed (1606 skipped by PRE)
  PROVE deposit: PROVEN — POST holds for all inputs satisfying PRE
  PROVE withdraw: PROVEN — POST holds for all inputs satisfying PRE
  1200
  700

How does it do the proving?

Spawns and calls z3 under the hood, I did let it cheat there because otherwise it's rabbit holes below rabbit holes all the way down :)

It came up a few weeks ago already, can't find the link

There have been a few.

A more explanatory article mentioned in the post: https://evincarofautumn.blogspot.com/2012/02/why-concatenati...

ah, thanks, that's why my first thought was that "hey, this feels very FORTH like"

I worked with Jason (creator of Om) at my last job. He's awesome!

is it his first language design ?

> any UTF-8 text (without byte-order marker) defines a valid Om program.

What is the behavior of a program with unmatched braces? I am not sure a stray `}` would fit any of the defined syntax.

https://www.om-language.com/index.html#language__syntax__

That would be parsed as a single operator and evaluated using the following rule:

> Evaluates to the operation defined for the operator in the environment. If none, evaluates to a constant function that pushes the operator, followed by all input terms, onto the output program.

I believe it would simply output itself.

I like how it unifies the operation stream with the stack (by pushing outputs back into the operation stream to process next).

An even simpler model than Forth, which evaluates an operation stream, with words that operate on a stack. And as noted, this makes recursion trivial.

I get the feeling there is something interesting here, but the website seems myopically focused on syntax. It doesn't really tell me what this language is good at or how you'd expect people to use it.

Om = Forth + Tcl ?

We've already seen Forth + Lisp

What's next? Lisp + Tcl ? Or maybe: Lisp + Forth + Tcl ? ;)

Forth + APL: Uiua

There are also APL + Lisp variants, like April, or even q from kdb+/q (kinda like Lisp but without parens).

---

The APL programming language (a subset thereof) compiling to Common Lisp.

https://github.com/phantomics/april

APL and LISP—should they be combined, and if so how?

https://dl.acm.org/doi/10.1145/800136.804474

Another concatenative-ish one embedded in js .. just for fun - https://github.com/srikumarks/pjs

You may find the "genailang" module fun to play with.

Has the CSS failed to load for me, or are the syntax diagrams meant to be that wide and blurry?

They are, works better on mobile but I don't like these diagrams, I think EBNF is more readable.

I confused this with https://github.com/omcljs/om

Yeah Om was an extremely widely used Clojurescript library many years ago (maybe still is), and to me that's what this word will always refer to.

I think Hinduism might have a prior claim.

https://news.ycombinator.com/item?id=47161422

Let's have more programming language posts (even about "retro" ones like Icon, SNOBOL, Bliss, MUMPS, etc.), guys.

And less about AI topics.

Om.

https://emojipedia.org/om

https://en.wikipedia.org/wiki/Om

And therein lies the tragedy of folks exploiting well known culturally loaded symbols/concepts for attention/etc. on the Internet.

For example, I really don't know what to make of this similarly named language; enthusiastic kid or attention-seeking influencer? - https://omlang.com/

people exploit anything for attention/etc. on the Internet.

if everyone on HN started downvoting all the AI posts (atleast the slop ones) it would cut down submissions by half

I think it's going to take some time for the reality of ns;nt and the disappointments to sink in. They need to learn that one cannot "claw" their way to a money machine.

This language is going to be a SuperHitPopular in India !!!

Missing a 'g'!

Omg would have a ring to it.

May I introduce you to the ultimate level of conciousness: https://en.wikipedia.org/wiki/Om

When you realize you were the missing "g" all along.

Outstanding work

What is the meaning and reason behind the choice of this specific name for the language?

The only two letter combination that is not already used by another language.

[dead]

[flagged]

Can you please not post shallow dismissals of other people's work? This is in the site guidelines: https://news.ycombinator.com/newsguidelines.html. They also ask you not to be snarky.

Nasty swipes like this routinely get upvoted, and then we end up with them at the top of a thread, choking out everything HN is supposed to be for. (I've downweighted it now.)

It's clearly a language designed for people interested in programming languages. Plenty of straightforward examples to show what makes this language interesting/different/worth your time.

But if you're incurious about things that aren't immediately practical (which has sadly been a growing number of HN community in more recent years), you will probably not be interested.

In an era when so much "practical" coding can be offloaded to an LLM, I'm particularly interested in seeing languages that are doing something different even if it makes them initially impractical.

> In an era when so much "practical" coding can be offloaded to an LLM

I see what you did there with the parentheses.

Turned them into quotation marks?

I don't think the project wants any "takers" per se. The first sentence describes it as:

> a novel, maximally-simple concatenative, homoiconic programming and algorithm notation language

This is a toy language designed to showcase a novel programming paradigm.

Personally, I like tech demonstrations, so I scrolled down and found the examples section. That's all I was hoping to get out of this interaction.

I would at least update body tag to add basic css to make this more readable:

    <body style="width:80%;margin:auto;">

There is nothing wrong with the site as it is. The text reflows, so you can size your window to any width that you find comfortable. With a decent window manager this is just a few keystrokes at most.

A huge chunk of people don't have, want or care about a "decent window manager" (and many of them are competent developers) and they'll just bail.

Life can be a dream if you don't treat everything as a pitch

Seems totally appropriate to the project. It’s like going to a GitHub repo and scrolling to the Readme.

Yeah show me the 5-line HTTP server

not that kind of language, it does not even come with integer types or "plus" operator by default.. they do give an example of

    define { minutes { dequote choose {minutes} {} = {:} <-[characters] } } { minutes {1:23} }

    "1:23".split(":", 1)[1]

    def minutes(x): 
        return x[1:] if x[0] == ':' else minutes(x[1:])
    minutes("1:23")

"The Om language is not:

complete. Although the intent is to develop it into a full-featured language, the software is currently at a very early "proof of concept" stage, requiring the addition of many operations (such as basic number and file operations) and optimizations before it can be considered useful for any real-world purpose. It has been made available in order to demonstrate the underlying concepts and welcome others to get involved in early development."

I am always kind of surprised when I go to a landing page for a language and there isn't any actual code. This is one of my biggest complaints about the rust language page, it feels crazy to me that there's no code and I think this is just a ridiculous choice (and I know this has been brought up before).

The old page had a built-in sandbox. Go used to have a more "Front and center" sandbox too but at least it's there if you scroll down https://go.dev/

> I am always kind of surprised when I go to a landing page for a language and there isn't any actual code.

So, you're not surprised that this Om page has an extensive section called "Examples", right? https://www.om-language.com/#language__examples__

I didn't scroll that far, and I shouldn't have to.

One time, this annoyed me so much that I made a website.

https://anaminus.github.io/langding/

om would fall under "Yes, must scroll".

Fascinating! It almost seems like the more popular a language is the less likely it is to have syntax on the landing page.

Popular languages don’t have to sell themselves anymore. No one goes to rust or pythons website to see if they would enjoy the syntax

There is code. Small examples start halfway down the page, and there's one 20-line example. Not much, but it's not accurate to say there's none.

It would be helpful to see any kind of motivation for the project though. Anything at all.

On my phone that code is about 250+ lines down, probably 4-5 screens down.

It basically doesn't exist as far as marketing is concerned.

marketing isn't concerned, it's an experiment in programming languages. the attention of someone who needs to eyeball the syntax before they understand how to read it has zero value to a project like this.

So it just needs a TOC.

No, it needs a 5 line code snippet above the fold.

splashing code examples at the audience encourages superficial assessments of the language.

There is code, search for 'examples'.

It concludes by implementing a fold:

   define
   {
       [Fold]<- {
           rearrange
           {
               rearrange
               {
                   dequote
                   choose
                   quote Result
                   pair pair pair {[Fold]<-} Function Result Remainder
                   Remainder
               }
               {Result Remainder}
               dequote Function Base <-[terms] Source
           }
           {Function Base Source}
        }
   }
   {
       [Fold]<- {[literal]<-} {} {1 2 3}
   }

great example! as someone who writes a Fold function every day, this explains the power of the language very well. ;)

i'm really not trying to be snarky or anything, but right at the top of the om page it describes the language as concatenative and homoiconic. without searching that or asking an llm, do you know what those terms mean? or what fold is?

could be there's nothing wrong with the page and you're really just not the audience for it. hacker news has many currents, most of which don't interest me, and that's fine, i don't feel the need to weigh in on everything.

As is clearly explained on the web page, this is not a programming language for everyday tasks, it's an early stage proof of concept that can be used to explore how computer science might be expressed in unusual ways.

Implementing fold would be something of a milestone in such a language.

At least it has examples!

It perplexes me that someone would not have a few cookbook style examples above the fold on a website that describes a novel programming language.

Will never not complain about languages not giving code examples. It’s like writing a charting/UI/style library and showing no examples. Just what?

You overlooked the examples. They might not satisfy you, but there are examples.

To be fair, the examples are extremely easy to overlook. They are also, to put it delicately, not the most helpful.

The examples are fine for an early-stage poc project like this one. `minutes` with evaluation trace and `[Fold]<-` are illustrative, and if you work them out with pen and paper, you can get a good grasp on the main ideas of the language. That you have to search for them on a page that looks like a slightly-formatted README instead of having a nice scrollable with syntax-highlighted snippets at the top is because this IS a slightly-formatted README - and that's also completely fine at this stage. What's important is that there are a few interesting concepts there and that it was published. Even if this one fizzles, as 99.999% of languages do, that doesn't matter if some other language down the line gets inspired by those concepts.

Absolutely agree. But fairness precludes denying the existence of examples.

They are not prominent, but they are in a section with the heading 'Examples'.

apparently fold example is very helpful to some.

if it's something you do 100% of the time, is it really adding any information to the world?

absolutely does! for a new language that no one has heard of, it is essential that examples make at least a parallel with other languages. providing examples for mundane things is very useful to build the understanding with the reader who hasn't been writing a paper on OM language.