Awesome questions—let's unpack each one clearly:

Absolutely! These tools are called transpilers (source-to-source compilers), and there are loads of popular examples you’ve probably heard of:

• TypeScript: The most ubiquitous one right now—it’s a statically typed superset of JavaScript that transpiles cleanly to plain JS, so it runs everywhere JavaScript does.
• CoffeeScript: A concise, whitespace-focused language that compiles to readable JavaScript; it was a go-to for writing cleaner JS before TypeScript blew up.
• Haxe: A multi-target powerhouse that can transpile to JavaScript, C++, Java, C#, Python, and even PHP. It’s perfect for writing code once and deploying across totally different platforms.
• Kotlin: While it usually compiles to JVM bytecode, its Kotlin/JS target transpiles straight to JavaScript, letting you tap into JS’s ecosystem with Kotlin’s syntax.

Yep, tons! These languages don’t produce machine code at all—their whole job is to translate to another higher-level language which handles execution (either via interpretation or just-in-time compilation). Examples include:

• All the JavaScript-focused transpilers above (TypeScript, CoffeeScript, Kotlin/JS): They output JS, which runs in browsers or Node.js via engines that handle the low-level execution.
• Pug (formerly Jade): A templating language that transpiles to plain HTML—no machine code involved, just converting a cleaner syntax into browser-readable markup.
• Sass/SCSS: CSS preprocessors that add variables, mixins, and nesting, then transpile to vanilla CSS that every browser understands.

Short answer: Absolutely—it’s a wildly viable shortcut, and way simpler than building a full compiler that targets machine code or a custom VM from scratch. Let’s break down the tradeoffs:

The Upsides: #

• Lower barrier to entry: You don’t have to tackle the messy work of machine code generation, optimizing for specific CPUs, or building a runtime environment. Instead, you leverage the existing ecosystem and tools of your target language (like JS’s massive library ecosystem or the JVM’s stability).
• Faster launch: You can get a working language up and running quickly by focusing on your unique features (like better syntax or specialized tools) instead of reinventing low-level wheels.
• Built-in compatibility: Your language automatically works on every platform the target language supports. For example, a JS-transpiled language works in every browser and on Node.js without extra effort.

The Downsides: #

• Potential performance overhead: Since your code goes through an extra translation layer, you might not match the speed of a language that compiles directly to machine code. That said, modern transpilers (like TypeScript) generate super efficient code, so the overhead is negligible for most apps. For hyper-performance-critical code, though, you might hit limits.
• Target language constraints: Your language can only do what the target language allows. If the target lacks a feature you want, you’ll have to hack around it, which adds complexity.
• Debugging hurdles: Debugging transpiled code can be trickier, since you’re looking at generated code instead of your original source. Most modern transpilers support source maps to fix this, but it’s still an extra layer to manage.

Overall, transpiling is a fantastic way to build a new language—especially if you want to focus on innovative features without getting bogged down in low-level implementation. It’s totally feasible, and many successful languages have taken this path!

内容的提问来源于stack exchange，提问作者Jason Nümbär