So if you don't want to use Apple's AI, this brings... faster app launching on iOS? I guess I'll use the Liquid Glass controls, but otherwise this is a dud.

> Otherwise this is a dud

This comment is a dud. The whole point of this update was to focus on fixing bugs and improving stability. They literally rewrote the CPU scheduler to improve UI performance. Safari UI and page rendering is no longer shit compared to how it was on iPadOS 26. There’s an insane amount of under the hood changes for this release, something people have been asking for them to do for a while — focus on making things run better instead of adding endless new half baked features.

Updates don’t always have to bring shiny, flashy new features. Holy shit.

The linked page is 90% AI and not much about stability. If "the whole point of this update was to focus on fixing bugs and improving stability" they don't say so, so excuse me for not knowing that.

If it's a stability release, then great! But that's not what they're saying. Stability is mentioned once regarding search only. Performance has a very small sub-section half way down the page. Where do they mention the CPU scheduler rewrite, or any of the under-the-hood changes you're talking about? You seem to expect people to know about these things from somewhere else.

They discussed it in the Keynote https://www.newegg.com/insider/ios-27-performance-boost-ever...

I mean, this is nice:

"Apple framed WWDC 2026 around three pillars: platform improvements, trust and safety, and Apple Intelligence."

and it could have been mentioned in the launch announcement post.

Compare it to 18 before the UI fail and you might have a non-dud of a response. And no, it wasn't the whole point, just read the announcement to see how much space is devoted to other points

Snow Leopard was one of the most celebrated Mac OS X updates for a reason.

I'm working on a new programming language for WebAssembly GC, called Zena: https://zena-lang.dev/

It's like a fixed up TypeScript specifically tailored for Wasm GC that can produce very small and fast binaries, but also has features like pattern matching, ownership / borrow checking for resources, pipeline, tail call elimination, multi-value returns, direct WASI component integration and a lot more.

This looks pretty cool! I love TypeScript. Although for my server-side apps, I just use Deno and compile my executable that way.

I have pondered cloning Caddy in TypeScript just because...would Zena be capable of this?

Nice list. I have a new language I'm working on (called Zena: https://zena-lang.dev/) with all of these in some form:

If you have static types and unions, control-flow analysis and narrowing is critical for avoiding an excessive amount of casts - and if you also have pattern matching, you get very nice style where a type-check, state extraction, and branch are all one expression.

Borrow checking. Zena is a GC'ed language, but it runs in Wasm and lots of Wasm resources are external, so Zena has affine types and second-class values for managing resources and disposing of them when no longer used. GC + borrowing is a great combo because you don't need borrowing for everything and lexical lifetimes with a few escape hatches cover most things. The ownership system is also great for modeling structured concurrency.

I'm working on contracts after borrow checking is complete. My impetus there is AI-generated code. If humans still review at all, reviewing the contacts more than the implementations makes managing large amounts of changes easier.

I'd like to see a few more good ideas spread:

Formal verification. Contracts should be a good stepping stone into a spec language, from there a proof language and checker. This should also be good for AI-generated code.

Numeric unit types / units of measure with dimensional analysis. We should be able to say that a variable isn't just a f64, but a f64 of meters, and when divided by seconds, give a velocity. I don't know why this hasn't made it into more mainstream languages, but it seems like it makes programs more clear, not just statically safer. For synax, my plan is to parameterize scalars by units, like f64<m> vs f64<s> and have units like `m` and `s` be associated with dimensions like `length` and `duration`.

Async cancellation. I added cancellation as a first-class language concept in Zena so that it can be handled like exceptions, but aren't exceptions. It extends try/catch to try/catch/cancel/finally. When a task is canceled, a cancellation unwinds the stack starting from the next suspension point (await). The benefit here is that you don't have to remember to check for cancellation in async functions - they're all cancellable.

Zena looks super cool! I was wondering if you could walk me through this syntax thats part of the example loops:

``` let iterator = items.[Iterable.iterator](); // <--- this part in particular is confusing me while (let (true, item) = iterator.next()) { console.log(`next: ${item}`); } ```

Dimensional types and formal verification make me super excited to see more of this language. You also probably mention this somewhere and I'm missing it, but any thoughts on adding pure functions / more general mutability enforcements?

Thanks!

So `items.[Iterable.iterator]()` is invoking a symbol-keyed method.

It's declared like:

    export interface Iterable<T> {
      static symbol iterator;

      [iterator](): Iterator<T>;
    }

    export MyArray<T> implements Iterable<T> {
      [Iterable.iterator]() { ... }
    }

This is similar to JS, where you can access properties of an object dynamically with [] notation, but Zena is static and doesn't have any reflection (yet) so the symbol has to be declared and statically resolvable, and Zena has operator overloading an a [] operator so we need a way to differentiate between symbol-keyed access from indexed access ([]), thus the o.[] syntax.

I do want to add pure functions, especially for compile time constants. I want to add a macro system that can either run pure functions (on the AST or IR, not sure yet) at compile time, or run arbitrary code sandboxed in a Wasm module.

Wow, this is really helpful and timely!

I'm building a new language with async/await and had to make a lot of these decisions, but I didn't have this organized of a framework to ground myself in. I'm happy to see it clearly that I choose mostly Trio with a bit of JavaScript.

My language (Zena's) async docs page: https://zena-lang.dev/guide/async/ I think I might do a pass and try to call out the decision points more explicitly.

fwiw, I found this post on cancellation by the author of Trio to be vey compelling: https://vorpus.org/blog/timeouts-and-cancellation-for-humans... and I based the cancellation design of Zena on it.

Edit to add: I do wish this included JavaScript's AbortSignal in the Cancellation section. Not because it's good, but because passing cancel tokens is a pattern that exists. There's also the dimension of who can cancel and, like AbortSignal, whether tasks have to opt-in to cancellation checks.

I definitely find trio (formerly curio) to be so thoughtfully designed at every turn; it's dispiriting that it never seemed to gain much of a user share over asyncio (whose main advantage appears to simply be inertia and stdlib privilege)

Since this exercise was pseudo-code, I did not think particularly hard about the semantics of specific implementations, I just reasoned about what I would naively expect from any implementation. The answer I gave was the Trio answer - this was the first time I heard about Trio.

I realized I have very little experience with async/await; I've only used it extensively in Javascript and only in the browser there - so if my understanding of the exercise hinged on semantics of child_process.spawn then I had no reference point at all for that.

The languages that I have used extensively for back-end work either have native green-threads (Elixir, Haskell), or further back in my career I simply used synchronous I/O in Java and C# which only offered async or futures long after I'd moved on from them.

Frankly, this is a big part of why I chose Elixir and Haskell (and lately, some Go).

edit: Also thanks for your work on Zena, and mentioning it here! I've looked for exactly this before. Now I just have to invent a project for it :)

SQLite bindings should absolutely not belong in a JS "standard library". SQLite is a project that most JS environments won't have enbedded.

There should be a space between "in the standard library" and "in a library written by some random person with a github account". An sqlite driver does not need to be bundled by the runtime, but it would be pretty great if there was an official sqlite driver library developed and supported by the node.js project but distributed through NPM.

Cool to see this pop up today.

I'm building a new language and just a couple of days ago the concept of guard methods came up as I was trying to tighten up equality semantics to be more like Swift.

Things like Array.contains() only work if the element type implements the Equatable interface, so it would be a guard method. Maybe something like:

    class Array<T> {
      contains(value: T): boolean where T extends Equatable { ... }
    }

Or possibly a constraint on the `this` type, TypeScript style:

    class Array<T> {
      contains(this: Array<T extends Equatable>, value: T): boolean { ... }
    }

https://github.com/elematic/zena/blob/8d77f2b36001078f4d5054...

"can only be good" - you can't imagine ways in which they at least could be bad?

Please add Wasm support :)

I'm making a whole new language to get around the problem you're talking about: it brings no runtime at all. One of my targets is a Sandstorm like system I've been slowly working on, but I'd love for it to be a fit for the actual Sandstorm successor.

There is a significant difference between experiencing an apple through your own faulty senses and reading words from someone else who experienced an apple through their senses.

You've just described Mary's Room - https://en.wikipedia.org/wiki/Knowledge_argument

It's his blog. He can talk however he wants. You, however, don't have to read it.

When the blog post is under discussion, I think comments critical of it are just as fair game as ones which appreciate it. If the parent poster was emailing the author to make the same complaint then I think the "you don't have to read it" criticism applies, but not so much in a discussion forum. The point is to discuss what we think, even if that is a critical opinion.