Modal is a matrioshka language based on pattern-matching to rewrite trees

I'm Wryl, the original author of this language. I sketched it out in late 2018 and played with it in 2019 after seeing some Mill architecture articles floating around. I mostly created it out of spite, thinking "You don't need fancy designs to do high-level things on bare metal!"

At the time, I called it a term rewriting language, which seem a bit of a weaker label than what it is. It's more like a string rewriting system with variables and nested strings, with parentheses acting as the separators for sub-strings.

It got to the point where I could transcribe Quicksort from the Haskell wiki into a fragment of Modal. I stopped playing with it after I had some not-so-fun industry experiences, and declared my work a dead-end.

Devine from Hundred Rabbits managed to get me to talk about it a bit more, and has taken the language far beyond what I could dream of. It's now gone beyond a sketch to a genuine marvel of engineering which is continually being refined as we figure out more idioms. The language is in very good hands.

I'm of the opinion that rewriting is an unexplored paradigm, and that we don't really understand how to build software. Modal was a product of my research efforts, which are still on-going. I hope to bring more projects like this to light. This has been quite fun.

A sample.

   (-- ?x) ()
  -- (Now we can add comments to what we are doing.)
  -- (Let's add some alternative syntax for defining rules.)
   (?x -> ?y) ( ?x ?y)

  -- (Let's add some boolean operators, 'and' and 'or'.)
  ((true)  && (true))  -> true
  ((true)  && (false)) -> false
  ((false) && (true))  -> false
  ((false) && (false)) -> false

  ((true)  || (true))  -> true
  ((true)  || (false)) -> true
  ((false) || (true))  -> true
  ((false) || (false)) -> false

  -- (Some alternative syntax.)
  (?x and ?y) -> (?x && ?y)
  (?x or ?y)  -> (?x || ?y)

  -- (Let's build an 'if' statement.)
  (quote ?x)    -> (quote ?x)
  (unwrap (?x)) -> (unwrap ?x)
  (unwrap ?x)   -> ?x
  (
    if ?c
      ?t
    else
      ?f
  ) -> (
    if/else ?c
      quote ?t
      quote ?f
  )
  (
    if/else (true)
      quote ?t
      quote ?f
  ) -> (
    unwrap ?t
  )
  (
    if/else (false)
      quote ?t
      quote ?f
  ) -> (
    unwrap ?f
  )

  -- (All together.)
  if ((true) and ((false) or (true))) (
    Hooray!
  ) else (
    Boo!
  )

This means that the above sample is effectively your "assembly language". There was no gap between your programs and the hardware they ran on.

Modal can be used to write small utilities, games, programming language implementations, type systems.. the list goes on. It's a fully general meta-language that can be used for general purpose programming.