From the article:

‘“The people who designed it understood that in a 7-million-person city like Bogotá, a very small percentage would actually see the mime artists,” says Felipe Cala Buendía, the author of Cultural Producers and Social Change in Latin America. However, Mockus believed in the power of word of mouth.’

> mimes … word of mouth

Nice.

Amazing.

I used them at the (US) Naval Research Laboratory, programming in a dialect of C called C*. This automatically distributed arrays among the many processors, similar to how modern Fortran can work with coarrays.

If the problem was very data-parallel, one could get nearly perfect linear speedups.

I use it to run Julia on my phone: https://lee-phillips.org/juliaOnPhone.jpg

Do you have instructions somewhere for getting this to work? I've tried installing julia on termux a few times with no success.

I just downloaded the archive (from the usual Julia downloads page) for ARM on the phone and put a link to the binary in /usr/local/bin — same as on Linux desktop. But I did this in the proot Debian environment.

Ah I see. Even after installing proot Debian I couldn't get juliaup to work, but I'll have to give it a shot manually installing the binary and linking to /usr/local/bin

Nice. I put this in my .zshrc.

Strange. Never had it happen regularly in the US.

I've never once experienced this nor literally ever heard anyone say someone gave them made-up directions in the US.

The only time I've ever experienced made-up directions were trying to get out of the souk in Marrakech.

> I've never once experienced this nor literally ever heard anyone say someone gave them made-up directions in the US.

Wouldn’t know. After the first two instructions I can never remember what came next.

I was unclear. I’m pretty sure the wrong directions I routinely got in the US (I was born and raised in NYC) were not made up, just wrong.

Google started as a company that seemed worthy of trust. The founders had ideals and followed them. Look what happened. Companies can turn evil surprisingly quickly. I'm also a Kagi customer, but I wouldn’t use a closed-source browser either.

It’s just transient fashion, driven by people who don’t read books. In another few years the same type of people might be using “employ” or something instead of “utilize”, or returning to “use”.

If you want your English to be good, try to spend more time with books, and less time with anything written after about 1960. This (excellent, and free) advice applies to native speakers as well as those enjoying English as a second (or third, etc.) language.

“unsticking myself always seems to be a matter of finding a name for the thing happening to me”

“That's why having goofy names for them matters so much, because it reminds me not to believe the biggest bog lie of all: that I'm stuck in a situation unlike any I, or anyone else, has ever seen before.”

Could you briefly explain why Pandoc was not sufficient? (Obviously it can’t do the TikZ -> CeTZ conversion.)

Great question! I love Pandoc and use it often, but as a "universal" converter, it sometimes misses the nuances of specific pairs. Tylax is designed specifically for the LaTeX $\leftrightarrow$ Typst workflow. By focusing on just this 1-on-1 pair, we can offer: Better Math & Macros: A built-in macro expander handles custom commands (\newcommand) and complex nested math that general parsers often struggle with. Cleaner Code: The output is designed to be idiomatic and human-readable (e.g., using native Typst functions), not just "compilable." WASM Support: Being written in Rust means it runs instantly in the browser, making it easy to embed in web apps without a backend. Pandoc is the Swiss Army knife; we're trying to be a specialized tool just for this specific transition.

Pandoc does know how to expand LaTeX macros. For example, given the LaTeX

  \newcommand{\pair}[2]{\langle #1, #2\rangle}
  $$\pair{a^2}{\frac{\pi}{2}}$$

pandoc will give you the Typst

  $ chevron.l a^2 \, pi / 2 chevron.r $

which is correct. Tylax, on the other hand, seems to have problems with this example, producing

  $ angle.l^()frac(pi,)angle.r  $

which does not compile with typst. Going the other direction, pandoc also understands typst scripting. For example, from

  #let count = 8
  #let nums = range(1, count + 1)
  #let fib(n) = (
    if n <= 2 { 1 }
    else { fib(n - 1) + fib(n - 2) }
  )

  The first #count numbers of the sequence are:

  #align(center, table(
    columns: count,
    ..nums.map(n => $F_#n$),
    ..nums.map(n => str(fib(n))),
  ))

pandoc produces this LaTeX:

  The first 8 numbers of the sequence are:

  {\def\LTcaptype{none} % do not increment counter
  \begin{longtable}[]{@{}llllllll@{}}
  \toprule\noalign{}
  \endhead
  \bottomrule\noalign{}
  \endlastfoot
  \(F_{1}\) & \(F_{2}\) & \(F_{3}\) & \(F_{4}\) & \(F_{5}\) & \(F_{6}\) &
  \(F_{7}\) & \(F_{8}\) \\
  1 & 1 & 2 & 3 & 5 & 8 & 13 & 21 \\
  \end{longtable}
  }

With the same input, Tylax produces:

  The first 8 numbers of the sequence are:

  \begin{center}

  \begin{tabular}{|c|}
  \hline
  \hline
  \end{tabular}\end{center}

which is just an empty table.

You are absolutely right. Thank you for pointing this out! Regarding your questions: 1. The `\pair` issue: This is definitely a bug. My macro expander is based on text replacement and obviously cannot handle nested parameters. I will fix the recursive logic. 2. The `fib` loop: Pandoc seems to use `typst-hs`, which contains a complete Typst evaluator. Tylax is strictly designed as a static AST transformer. We haven't implemented the Typst virtual machine, so loops or recursive functions cannot be executed. This will be gradually improved later to make it more usable; my claim of "better macro support" was clearly premature. This was a big mistake on my part, and we will strive to achieve this goal in future updates! Thank you very much for your feedback and for pointing out the bug!

That makes sense, especially the issue with macros. As many people have pointed out, since TeX is not just markup but an actual programming language, its output can not be determined, in the general case, without running the source through the TeX interpreter. Of course, the same is true of Typst.

You are absolutely spot on. Both systems are Turing-complete, so a perfect conversion without a full runtime execution is theoretically impossible for the general case. That's exactly the trade-off Tylax makes: we aren't trying to be a full TeX engine (which would be overkill and slow). Instead, we aim to cover the "99% use case" of academic and technical writing—where macros are mostly used for shorthand, notation aliases, or simple formatting, rather than complex computation. Our "limited macro expander" is the middle ground: it's dumb enough to be fast and safe (no infinite loops), but smart enough to handle the \newcommand shortcuts that riddle almost every paper. It's about being pragmatically useful rather than theoretically perfect

I haven’t tried this out yet but my gripe with pandoc is that it produces latex (and typst) that no human would ever write. It looks messy and is annoying to share with coauthors.

This is not to say that pandoc isn’t a fantastic tool.