9 comments

  • afavour 2 hours ago
    Fascinating. I've written cross platform (WASM, iOS, Android) libraries with Rust before and had a good time but Rust can be a pain too. Cross-platform Typescript is a really interesting proposition.

    That said, the more I think about it the more dubious I am. The site boasts no runtime dependencies but clearly it’s going to need things like a garbage collector, you can’t just magic that requirement away. At a certain point is it just doing what a JS engine’s JIT compilation does… except ahead of time?

    Also doesn't inspire confidence that the text on the site is very clearly AI generated and the GitHub log shows an endless stream of AI powered commits. About 15 per hour, every hour? Doesn’t scream stability.

    • metaquestions 21 minutes ago
      how do one tell when text is ai generated - honest question. What are the tell tale signs?
      • leidenfrost 3 minutes ago
        In regards to the site, all of them follow almost the same templates.

        Once you see a few, it becomes obvious

    • __s 1 hour ago
      tbf Rust also can spit out pretty big binaries for small programs
      • afavour 1 hour ago
        Agreed. You can optimize things a fair amount with the Rust compiler, at least.
  • koteelok 2 hours ago
    Calling a couple million lines of ai written Rust "stable software" is a bold statement
    • fooker 14 minutes ago
      vibeware :)
  • fooker 12 minutes ago
    Why go through LLVM at all?

    There are a bunch of tools that JIT somewhat optimized assembly.

  • madanparas 1 hour ago
    Perry uses NaN-boxing to preserve TypeScript's dynamic type system at runtime, the same approach as JavaScriptCore. The PERF_ROADMAP is honest about the cost: 1.86x behind Zig on image convolution, with 1.24 billion wasted instructions traced specifically to NaN-box unboxing. You cannot get C-level performance without dropping TypeScript semantics, and dropping them means you are no longer compiling TypeScript.
    • Dylan16807 1 hour ago
      I think you mean you can't get that performance without monomorphization. When you know the types you can...

      ...wait, I went and looked up that file.

      "The Three Optimizations That Would Close the Gap"

      You're presenting the data from there in an extremely misleading way! They in no way need to drop any Typescript semantics to go faster.

      • cornholio 25 minutes ago
        Typescript is a dynamic language. Without changing the language, there is fundamentaly no way to resolve at compile time decisions that can be made only at runtime (ie, they are data driven). Monomorphization helps pin down (some) dynamic types but the fundamental problem remains.
      • madanparas 36 minutes ago
        You're right. The typed buffer locals optimization keeps TypeScript semantics intact by exploiting the existing Buffer/Uint8Array type annotation to skip the NaN-unbox. It's not dropping types, it's using them. The floor I described applies to any-typed paths where static type info isn't available. For well-typed TypeScript, the roadmap shows the gap closes without semantic changes.
  • evil_buzzard 2 hours ago
    the claim of "no runtime" is a bit dubious... you're telling me that you're statically linking a full, modern UI library into every app?
  • 0x1997 2 hours ago
    • koteelok 2 hours ago
      The screenshots in the showcase look goofy
  • __s 2 hours ago
    Curious where on spectrum compiling to wasm falls between art project & optimization potential. Should be able to make some nice interfaces between TS-wasm & TS-web
  • smasher164 42 minutes ago
    I'm not against AI usage but the website, documentation, and even the comments the creator (proggeramlug) makes in response to questions are all very clearly AI-generated. Also, as someone else noticed, the pacing of the commits is eerily fast. That combined with the level of functionality makes me dubious how much accountability the creators have over the implementation.

    Like you really built a backend that lowers to LLVM, integrated it with a generational gc, wrote a cross-platform reactive runtime, and built support for eleven different targets within like a year? Are you just prompting the model to tack on the next coolest thing or do you understand how these features work?

    I worry how many of these kinds of projects will show up now. How do you guarantee stability? If there's a memory corruption error in the GC implementation, who's going to debug it?

    • fooker 16 minutes ago
      This is how software development works now. We have to live with it.

      The models are good enough that this works.

      You can keep disagreeing for a while, but know that almost all the code in the industry is written like this now.

  • haeseong 1 hour ago
    [flagged]