Pinned Tweet
The core motivation behind the Zed programming language: "write once, parallelize anywhere"
github.com/zedlanguage/zed/w…
The Zed Programming Language retweeted
Replying to @annimvs @patloeber
It is none of the three. @ZedLang uses a custom entailment engine based on entailment by refutation with the Omega test (Pugh). "Premises entail goal" is checked as "(premises ∧ ¬goal) has no integer point," using exact integers of unbounded size.
* The decision procedure: Equalities are solved first, using Pugh's symmetric remainder. Then variables are eliminated one at a time, preferring exact eliminations, and choosing each time the variable whose elimination adds the fewest rows. When no exact elimination is left, it tests the "real shadow", then the "dark shadow", then searches the splinters.
* Exact special cases: These are decided before elimination starts. Constraints over two variables are settled by counting integer points under their envelopes. Constraints of the form ±x ± y + k ≥ 0 are settled by a parity test on cycles of the constraint graph.
* Disjunctions: They are not expanded into disjunctive normal form. Disjuncts that cannot meet the conjunctive base are pruned until nothing more can be removed, and then the remaining choices are searched in a fixed sorted order, so the result does not depend on how the source is written.
* Nonlinear terms: A product x·y is treated as an atom of its own. Before solving, the premises on each factor are multiplied in pairs. If that fails, it tries again using tighter bounds the solver finds, first over each factor's cluster and then over the whole part. Any countermodel is checked against the true reading of the products before it is reported as a refutation.
* Results: Every answer is one of four: proved (with the premises it used), refuted (with a countermodel), not proved by the linear reading, or refused. A refusal happens only on system shapes the method cannot settle, and it is sound: the written constraint is simply kept.
* No budgets: There are no timeouts or iteration caps anywhere.
Today the same solver is used for satisfiability and projection during narrowing.
The Zed Programming Language retweeted
The impressive part isn't just recall. It's connecting decades of research to a new design problem in seconds
let’s connect
The Zed Programming Language retweeted
It's going to happen whether we like it or not... I am spending thousands on tokens that others will benefit from... but I choose radical openness. Can someone take all my work of 20 years and morph it into something way better in a weekend or a few weeks, and steal all my users too? Of course -- that's the new reality, we all stand on each other's shoulders, and the cost of doing so is going to zero. But I am just going to keep innovating, since now I have an army of engineer agents at my command. We all need to buckle up -- the ride is going to be wild.
The Zed Programming Language retweeted
Replying to @flowerornament @doug_tarr
You and I are on the same path for sure...
My static checker code is an exceptionally complex constraint satisfaction system that simultaneously solves type constraints, type domains (e.g. `x : int[a..<b]`), algebraic constraints (e.g. proving `x mod 3 == 3` is always `false`), and a lot more. (Most problems I am trying to solve in the checker are NP-complete or coNP-complete in the general case. However, I tasked Opus with finding fast, precise, correct solutions for large no-pathological subsets of the problem space.)
Combined with the fact that @ZedLang uses partial evaluation pervasively to specialize code, the compiler can't just run the static checks as one stage of compilation: some code will need to be partially evaluated, which provides concrete values that need to be substituted into code that needs to be checked algebraically, which can result in a condition that enables a new chunk of code to be fully specialized via partial evaluation, which can unlock further static checking, etc.
So I rebuilt this all from fixed form pipeline into a new generic task system built on the DAG of dependencies induced by the structure of the code and the structural needs of the static checker -- kind of like the transition around 2006 from fixed-T&L-pipeline GPUs to gpGPUs, which enabled the DL revolution. This sounds similar to your "graph machine".
Yes, you don't want to lower to flat IR too fast -- keep things in graph structure as long as possible, until you have to pick an execution plan and a topological-order serialization of the code.
The Zed Programming Language retweeted
I outlined to Opus 5.5 my proposed design of an arena-based scoped memoization system for @ZedLang, and asked it to research existing work in the literature and in other languages for comparison. Within a couple of seconds it listed what it will research. The fact it "knew" all of this "off the top of its head" is insane.
> Among others: region inference (Tofte–Talpin, MLKit), Cyclone, Rust arenas, Verona/Vale/Pony, Reaps, implicit parameters, Scala contexts, the implicit allocator context of Odin and Jai, Zig allocators, effect handlers, coeffects, eviction in Salsa, Adapton and Skyframe, and weak memo tables.
The Zed Programming Language retweeted
Replying to @arpit_bhayani
The problem with this approach is that LLMs are known to overfit tests (including formal verification) to the code that is already written, and not to the intent of what it is claimed is being proved. Already OpenAI have retracted at least three of their Lean proofs because even though those proofs compiled, they were proving the wrong thing.
Far better than this is to use a language in which the static analyzer is itself based on formal verification, so that the program is its own formal verification proof, if it compiles (ie. there is no Lean proof separate from the actual implementation itself).
Unfortunately there aren't many languages that can work this way today: at best you get static typechecking. But we now live in a day where we can create a new generation of languages that build Lean-like verification of code into the language itself.
That is what I am building with @LedLang.
(ETA is around 2 months away, and I have been working on this for 20 years, but the rate of development picked up significantly as of Opus 5.5 being released!)
The Zed Programming Language retweeted
Replying to @korulang
This is exactly what I have built in @ZedLang. You can declare an "atom" anywhere you want -- it's both an enum value that doesn't have to be declared as part of an actual enum, and it's an exceptional (error) value. So given a rational number `x : rat`, if you compute `y = if d != 0 { x / d } else { #divByZero }`, the type of `y` becomes the union type `rat | #divByZero`, and the type system enforces that anything that works with `y` handle the #divByZero case via pattern-matching or conditional guards. This can all be statically checked if it is core to the type system.
The Zed Programming Language retweeted
"Telling a programmer there’s already a library to do X is like telling a songwriter there’s already a song about love." — Pete Cordell
The Zed Programming Language retweeted
Replying to @doug_tarr
Definitely true. But I run a tight ship. My design doc is 2MB in size (developed in dozens of rounds of cross-checking and critical review from 200 pages of design notes assembled over the last 20 years), I converted the design into a massive (currently 1200-node) task dependency DAG (so that the agents never attempt anything too ambitious at any point, but are forced to work on microtasks), and every agent is held to exceedingly high standards (every new piece of code must not only be thoroughly tested and pass before it is merged, but it must pass benchmarking tests that prove it doesn't scale worse than O(n log n)). I also have my build prompt generating a live view of the task DAG so I can visualize what's going on.
Once I get this thing built I plan to have Claude analyze my entire process, including all steering decisions, and turn it into a prompt that anyone can steal.
The Zed Programming Language retweeted
Replying to @mkanat
You absolutely nailed it here. I have had so many people ask me "Why on earth would you build another programming language? We have great languages, and we don't need or want more". This feels delusional to me.
The languages we have today are atrocities, the result of decades of design by committee, and cruft buildup, and inheritance of technical debt, and lockin, and cultural intertia, and need for backwards compatibility, and resistance to change.
Finally, for the first time in 68 years since ALGOL was first released (where ALGOL was the first "real" programming language, upon which almost all modern programming languages are fundamentally based), we have the chance to reinvent EVERYTHING. Not just to create something incremental or evolutionary, suffering from all the same problems as previous languages, but to build something completely revolutionary and elegant: a new type of language which is self-consistent, composable, efficient, scalable, mathematically well-grounded, well-engineered, practical, ergonomic for humans, and also fun to use. And we can build, test, polish, and launch such an ideal language in the space of just a few months, complete with a massive, well-tested standard library, a complete formal language spec, and copious documentation and tutorials.
AND all this can be done by just one person with enough vision and tenacity to conceive of this better future and then being it into fruition.
This is such a miraculous time to be alive.
The Zed Programming Language retweeted
A lot of people wonder why a tremendously increased volume of code contributions can lead to very minimal increases in business value. There are many reasons for this, but I will tell you the one that I have been personally encountering the most often in my personal life outside of work:
I am constantly dealing with the fact that somebody else in the world did not do their job to the fullest in some way or another. Often, this is transitive: Person A did not do their job because Person B did not do their job and thus made Person A's job impossible or too difficult or wildly confusing. Sometimes this is a very long transitive chain going back to the designer of some fundamental tool or programming language that made everybody's life difficult.
When you dramatically speed up the pace of development, two things happen:
1. These paper cuts become tremendously more painful.
2. It becomes dramatically easier to fix them.
As a result, you spend a tremendous amount of your time either papering over or trying to actually fix the fact that somebody else did not do their job thoroughly enough. You end up caught up in a mass of fixing the tools and systems you depend on, rather than actually working on the product you're trying to build.
I genuinely believe that one of the true problems that we are dealing with is that the world is full of incomplete and broken software, and we are now very actively digging our way out of that hole.
You can actually see this too. There are some teams that manage to dig themselves out of that hole and then, all of a sudden, explode with productivity: real productivity, shipping real things. But it often takes months. I've usually seen it take about 6 months, almost at a minimum, for teams to dig themselves out of even some of the most shallow holes that people get themselves into.
I do think there's a danger here too, which is that some teams never choose to even start digging and just start piling it up more and more and more with the agents. I think those teams will never experience takeoff.
It's a tough situation, but I got to say: if you don't take advantage of the agents in a way that actually increases the quality of your tools, systems, and workflows (and that increases your own productivity over time), you are going to be left behind by a million miles by everybody who does, when they finally do dig themselves out of that hole.
When my agent swarm finds inconsistencies between different parts of the complex Zed spec, I have it write up a detailed problem analysis for me, spelling out all tradeoffs and consequences of different choices, so that I can make good judgment calls. Superpower unlocked.
1
5
571
Zed is looking about 1/3rd implemented. Here is the task dependency DAG: green = implemented; blue = waiting to start (all upstream deps are implemented, tested, benchmarked, optimized, and committed); yellow = currently implementing.
2
5
588
The Zed Programming Language retweeted
Guys there are SO MANY new programming languages being built. We're going to see an absolute explosion in language options in the near future, thanks to Opus 5.5 and beyond. People are finally scratching their own itch, and building what they always wished existed. My own (WIP) language is @ZedLang:
github.com/zedlanguage/zed
The Zed Programming Language retweeted
I’m making a programming language called blood.
Faster than rust, a powerful type system, all the power of effect systems, metaprogramming, zero-cost worktrees, semantic merging, sqlite-stored content-addressable code.
Psychosis? Hopefully not.
blood-lang.org
The Zed Programming Language retweeted
A lot of the core syntax and features of the Zed programming language are now published in the README.
The feature that I think is most revolutionary is the multi-level map: see "Remapping".
(Note: Zed is still being implemented to spec... it's a WIP)
github.com/zedlanguage/zed
A lot of the core syntax and features of the Zed programming language are now published in the README.
The feature that I think is most revolutionary is the multi-level map: see "Remapping".
(Note: Zed is still being implemented to spec... it's a WIP)
github.com/zedlanguage/zed
The Zed Programming Language retweeted
Modest intelligence is arriving faster than most people realize.
Today, we're open-sourcing TwIL-8B.
Just 8.8 billion parameters, yet approaching frontier-model scores on several difficult benchmarks:
• 93% of frontier performance on coding
• 92% on instruction following
• 90% on contest mathematics
All from a model small enough to run on your own hardware.
But the benchmarks aren't the most important part of this announcement.
For years, the AI industry has focused on building the most capable model, regardless of the cost required to run it.
I believe that equation is changing.
The next era of AI will be defined by the cost of completing work. Not simply the intelligence of the model, but how efficiently that intelligence can accomplish the task.
If a model with 8 billion parameters can reliably complete the same work as one with hundreds of billions, why pay for the larger model?
As smaller models become more capable, intelligence becomes something we can distribute, specialize, and run across the hardware we already own.
That's the future we're building at @thewebAI
TwIL-8B is available today. Open weights.
And this is just the first of several announcements we're making today.
HF Link: huggingface.co/webAI-Officia…












