[benjiro29]

The problem with these type of new / transcompile languages is not the langue, its the lacking libraries and 3th party assets. Great if just want the most basic hello world programs, but the moment you need ... for example a http server. Then your often with:

a) none

b) http 1.1

c) ... forget about more

Maybe you need rar support ... O well, ... And then you always enter the world where you need to start linking external libs, and then your mixing not just the base language and the transcompile but also whatever interface for calling those external libs.

Ironically, with LLMs being around, your often better to just have it write whatever is missing. Until you find out then, that the language misses some feature.

O great, you needed crypto support. Ok let the LLM write it for you, its only 100x slower then whatever was written years ago and had tons of enhancements and edge cases fixed.

At that point, you can just tell a LLM to write in C from the start, and be done with it. lol.

Transcompile languages have always had tons of issues, and there is a reason why non became popular. Haxe comes to mind. How many years this exist and barely anybody knows it. Because your often just better writing in the original language and fixing the issues, or picking a better fitting language for your project.

[win311fwg]

> Transcompile languages have always had tons of issues, and there is a reason why non became popular.

While implementations have all died out now in favour of direct compilation, C++ the language was designed to be a transpiled language, and was for many years with C as the target. You can likely find many who agree that it has tons of issues, but unpopular it is not.

[mpyne]

Typescript is an even better example. And there are some domain-specific languages that aren't meant to become popular general-purpose languages, but succeed in their niche through the help of transpilation to a general-purpose language.

[win311fwg]

Typescript isn't nearly as popular as C++ and, aside from a couple of legacy features that don't seem to be commonly used, it can be erased without needing transpilation. What makes it a better example?

[mpyne]

> Typescript isn't nearly as popular as C++

Huh?

You should reassess how your current understanding of language popularity compares to what's actually going on outside your environment.

Typescript has already surpassed C++ in popularity. [1] [2] [3] [4]

As a primarily C++ dev myself I wish that wasn't the case, but it is.

> aside from a couple of legacy features that don't seem to be commonly used, it can be erased without needing transpilation

"If you ignore the parts that don't need transpilation, it doesn't need transpilation". Well yeah, sure.

But even there, erasing types is still a transpilation, just an error-prone version of it. It's still being run as Javascript at the end, whether you actually compile to Javascript or use a frankentranspilation instead.

[1] https://www.libhunt.com/index [2] https://www.itransition.com/developers/in-demand-programming... [3] https://eu.36kr.com/en/p/3549523189739394 [4] https://survey.stackoverflow.co/2025/technology

[win311fwg]

> You should reassess how your current understanding of language popularity compares to what's actually going on outside your environment.

He says as he then tries to prove it by showing rates of use and mentions inside programming bubbles, forgetting that we're talking about popularity. Time to step outside into the real world, away from screens. Many non-programmers who make up the vast majority of the population have heard of C++. Typescript is largely unknown.

> "If you ignore the parts that don't need transpilation, it doesn't need transpilation". Well yeah, sure.

The earlier claim was that transpiled languages never become popular because of the impedance mismatch between the source language and the target language, which introduces a number of practical problems. If your language is identical except for a couple of features nobody uses then you will never hit the impedance mismatch spoken of. You are technically right in a vacuum, but what about the rest of the universe? It is an example, but it remains unclear how it is a better example.

> But even there, erasing types is still a transpilation

If we are ignoring the couple of exceptions, then that is debated. Some definitions of transpilation declare that there must be a translation to a different language. Typescript is the same language as the target with extensions.

Since the larger discussion is about Go, did you know that there is also a Go with extensions language that the gc compiler[1] implements? It is especially apt because it also only needs erasure. Do you consider it to be transpiled? Or is it just plain old Go, with extensions? The sentiment I see on HN is that it's just plain old Go, not a different language that needs to be transpiled to Go. Chances are you aren't even aware that this language exists because everyone just calls it Go as well. It isn't thought of as something else even though it technically is.

But we don't have to worry about semantics. What remains clear is that simple erasure doesn't run into the impedance mismatch problem, and thus doesn't run into what was originally claimed. Hell, even the exceptions, where Typescript truly requires transpilation by any definition, map fairly cleanly to Javascript so there still isn't any major impedance mismatch to run up against like there generally is when the languages have larger gaps in functionality. It is an example, but what makes it a better example?

[1] In case you are aren't aware, the gc compiler is the canonical Go compiler implementation provided by the Go project.