Speaking from personal experience, Godot has the sneakiest potential. It has all the UI components and flexible layout containers you could ask for, a signaling system that lets you put the methods from less relevant components in the scripts for more relevant ones (making for a more compact project), and you can also manually compile slim template builds for cleaner distribution. There's a future there.

There are already tools made in Godot, including the godot editor itself. This page has some of them: https://gamefromscratch.com/godot-developed-non-game-applica...

What’s the story for accessibility and non-LTR text boxes?

The greatest failing of modernity is its refusal to accept an uncomfortable reality uncovered by biology and psychology: That certain strongly negative personality traits are built-in pathologies which nature tries out to explore what is possible. The neural pattern that is "Trevor Milton" is not him without those intensely compulsive lying behaviors.

The social taboos of cultures around the world are fighting a ceaseless battle to reign in these endemic outliers.

This resonates as true, as long as the fundamentals of your tools are there. Picking interpreted languages or browsers as targets shoots you in the foot and sets you magnitudes behind when performance starts to matter. But if you're using a native-compiled language with value- and move-semantics, immutable data, and a composable type system, it's shocking how easy it can be to write obvious, maintainable, fast programs that perform under pressure, even when you're not being clever.

Thankfully newer languages like Nim, Odin, and Swift lean hard into value semantics. They drastically reduce the cost of focusing on data structures and writing obvious algorithms. Then, when bottlenecks appear, you can choose to opt into fine-tuning.

More generally: LLM effectiveness is inversely proportional to domain specificity. They are very good at producing the average, but completely stumble at the tails. Highly particular brownfield optimization falls into the tails.

Side-by-side, it's incredibly clear that the newest version is total UX garbage. Monochrome icons were a complete mistake, in basically all cases everywhere. A mix of the Lion color, shape/texture, and spacing, plus the Catalina sidebar, would be the best.

I really REALLY love the Lion icons. Colorful but subdued with only mild saturation, distinctive shapes, strong line borders with very slight halo, and mild gradients to make them pop.

I've recently made a dozen vastly different projects with Typst, ALL of which would have created dependency hell, syntax noise, and hours of extra pointless work in Latex. It's such a clear win at this point it's embarrassing.

reminds me of when LyX became trendy with a small group of optimists.

I mean, LyX has met my needs since 2019 - I don't particularly need to be optimistic about it. I was even able to bring in parts of my old LaTeX preamble with me, especially some utility macros. It was a pretty painless switch with immediate benefit.

(I've done everything in it from write honors theses and format CVs.)

I've been interested in Typst. But beyond report generation (which I avoid in general), I don't really have a general "document processing" tool, but multiple specialized ones, and given Typst's current jack of all trades/master of none status, I'm not sure what it'll replace. I use Quarto for a lot of my statistical computing, LyX if I need to do a lot of finicky math typesetting (e.g. if I need to break out \qquad), and Word - god forbid - for my non-technical collaborators.

LyX is pretty great. It has an equation editor that actually works very well - once you learn it it's much nicer than typing in the raw LaTeX.

If I had to use LaTeX, I'd definitely do it via LyX.

LyX is cool but it was still just on top of TeX. typst is much more fundamental.

I bounced off of Objective-C not because of its message-passing OO. That was the actual cool part. I bounced off because of the insane amount of boilerplate prototyping and headers required to use it.

I think every OO language should be using Smalltalk's message-passing style rather than holding hard references, and Objective-C is a great model. But discard the rest.

Apple should have made a modern Smalltalk on top of the Objective-C object model as a replacement for Objective-C instead of Swift.

I want to love Swift, but the funny thing is that as they solve more problem with Swift they also add so much complexity that you wonder if all the problems they solved just added new problems.

i really really like swift actually, it lets me express things that are harder in many languages...

that being said, i also feel this as well... idk i feel like swift went too hard in the static direction which makes a lot of things harder than they should be such as hot-loading while developing etc

New York City has been a running sine wave of sketchy stories and memories for the past century!

True beauty. Wow. My only ask would be optional type annotations for function and type parameters, so it's easy to fully describe your interfaces in code.

use [sig ...] for function types.

Major syntactic structures definitely have an influence on my language choices. Outside of compilation and runtime model, modeling the domain (both data and procedures) changes drastically between paradigms. Syntax is what enables or hamstrings different modeling paradigms.

My two biggest considerations when picking a language are:

- How well does it support value semantics? (Can I pass data around as data and know that it is owned by the declaring scope, or am I chained to references, potential nulls, and mutable handles with lifetimes I must consider? Can I write expression-oriented code?)

- How well does it support linear pipelining for immutable values? (If I want to take advantage of value semantics, there needs to be a way to express a series of computations on a piece of data in-order, with no strange exceptions because one procedure or another is a compiler-magic symbol that can't be mapped, reduced, filtered, etc. In other words, piping operators or Universal Function Call Syntax.)

I lean on value semantics, expression-oriented code, and pipelining to express lots of complex computations in a readable and maintainable manner, and if a language shoots me in the foot there, it's demoralizing.