Manyan is the fastest TLA+ Checker in the world (w/ the coolest logo).
And i have a big plan, BIG plan. Supporting Apalache is on the way.
github.com/soasme/manyan
24
soasme retweeted
We're still so small but I'm loving the team we've got at Superlogical. They're so talented and kind and love their craft. It's a different era of software development and our expectations and practices reflect that. I want to share a bit about how we work.
First, everyone is trusted to push to main. We do machine-aided code review pre-push and human plus more machine-aided code review post-push. Limited to no PRs.
Culturally, we've all agreed that if we ever hire someone who we DON'T trust to push directly to main, then they probably aren't the right fit for the team (so far, not an issue).
Some common sense here: if someone is stepping outside their lane or comfort zone, we'll open PRs. For example, I'm pretty trash at macOS/iOS UI, so I'll open PRs for UI-affecting functionality and ask for eyeballs/help. But for business logic and internals, I push to main.
Second, everyone can cut a release. Our release process is fully automated and when you start a release (for any platform) it triggers a Slack notification and a 15 minute countdown.
The 15 minute warning is a final gate that allows people to review plus collaborate on a changelog. During that 15 minutes, anyone in the company can pause the release rollout. After 15 minutes, the train leaves the station. You can't override the 15 minutes (except to pause). It gives everyone a chance to step in.
Third, we avoid synchronization through fast remediation rather than through planning. The server and clients on various platforms ship features as fast as they can. We use post-hoc human review and AI-assistance to identify feature mismatches across products ("Windows has support for X and Mac doesn't." or "Mac and Windows differ in their behaviors for Y in this way.").
This avoids expensive "sync" meetings and coordination. We trust that producers of features are mindful of what they're producing and we trust that adjacent product lines will self-synchronize quickly. In practice, we see feature parity across platforms within 24 to 48 hours.
All of this works on mutual trust. It ONLY works with mutual trust.
Everyone at all times has to trust that they've got each others back:
1. Push to main only works if you fix your mess, or if you don't, that someone else will quickly but that you'd do the same (and generally in equal amounts).
2. Anyone can deploy only works if you trust everyone to cut at the right time, with the right changelog, and that people will respect the 15 minute timer.
3. Sync through fast remediation only works if you trust other teams will pick up and integrate your work quickly, which only works if you would too. It also only works if you are fairly producing mismatches (e.g. not constantly).
We've got a great team. I know we're still small and that these practices will change in many ways as we scale. But this is already a markedly different practice than what I would've done 15 years ago.
In general, we are building from day 1 on a foundation of mutual respect, excellence, and trust. And it's been awesome.
soasme retweeted
I had Opus 5.5 formalize CPython in Lean: 613,318 lines of Lean that copy Python's internals line by line, tested against the real interpreter and checked by Lean.
On the way it found real bugs in Python, including crashes from plain Python code. 🧵
Jenson Huang chose the wrong spy to love. I'm sad.
Hey man, this one!
Ad: spy is a minimal embeddable Python interpreter implemented in C11.
github.com/soasme/small-pyth…
Benchmarked TLAPlusPlus against tla-rs, another great TLA+ checker utility.
TLAPlusPlus is 3x-22x faster. (tla-rs fails on two of my bench specs).
github.com/soasme/tlaplusplu…
1
39
TLAPlusPlus (tpp) v0.5.0 is out! github.com/soasme/tlaplusplu…
It can achieve generally 4x-5x performance gain comparing to TLC (official TLA+ model checker).
If your project uses TLA+ for formal verification, try TLAPlusPlus a drop-in replacement for TLC. Because life is short. 🤩
2
176
soasme retweeted
libghostty 1.0 is here! I started Ghostty ~5yrs ago to work towards this. Today, libghostty is in hundreds of projects used by tens of millions of people. 1.0 marks ABI stability, quality, and an invite for distros to begin packaging. mitchellh.com/writing/libgho…
Since starting the Ghostty project in 2022, the most common question I've been asked is "why?". Today, I'll answer this by showing the broad industry impact libghostty has already had.
On top of JetBrains and Neovim already mentioned (that alone being over 10 million users):
-KDE developers are experimenting with a Konsole replacement built on it.
- Vercel's Turborepo uses it to render task output in its TUI.
- devenv uses it to drive shells.
- Antithesis used it to fuzz TUI programs and found real bugs in btop and others.
-Ghostel brings it to Emacs.
- ghostty-web is the WASM build with an Xterm.js-compatible API.
- Commercial products like OrbStack embed it.
- And a whole wave of new terminals and "agentic" coding tools, such as herdr and cmux, have been built on it rather than writing yet another emulator.
There are community bindings for Rust, Go, JavaScript, Swift, Python, .NET, Elixir, Dart, Java, and more, and the awesome-libghostty list tracks well over a hundred projects.
More people today use a terminal powered by libghostty than use Ghostty the application, by a very large multiple. And libghostty is having a much larger impact than being "just" a terminal emulator.
I'm excited to see where people take it from here.
Life is short, use TLA++
github.com/soasme/tlaplusplu…
In runs same inputs and outputs as TLC but at least 2x faster.
while i'm quite bullish on formal methods, i think it's worth tempering expectations and doing your own research on it (disclaimer: i am not an expert in it). it cannot guarantee your code is bug free, only that it matches the spec under certain assumptions, and the specs come from what people want, not math. as long as we build software for humans, nothing can prove that your spec is right, only you can judge.
i created the /statechart skill in pstack primarily because it helps make the state machines implicit in your code more obvious and legible to you, so you can shrink the review surface and review the work at a higher level: does it actually match your intent and goal? i used this skill a ton while building my game tibo.dog, below you can see the statechart for story mode where i was able to find many bugs with it.
in that sense, i think model checking (eg TLA+ with TLC) is quite useful for understanding and checking properties of your system e2e, and you don't have to write tons of new verification code for it. the spec isn't your actual code so there's always a risk of drift, but so far i've had good experiences finding actual bugs with it. i tend to pair it with empirical verification (running the code) also to confirm it's real
other types of formal verification like proving theorems (eg Lean, Dafny), bounded model checking (eg CBMC, Kani) etc have their own tradeoffs. proofs cover every possible input, but only for the properties specified, and it takes a lot more code/work. bounded model checking can run on your actual code, which avoids drift, but it only checks up to a certain number of steps, so it's better at finding bugs than proving there aren't any
so i think in the near-medium term you'll still need to layer your codebase: constraints and guardrails (types, lint rules, api design, refactoring), empirical verification (tests, evals, real usage), and formal verification for the parts that really need it. none of these catch everything on their own, but layered together, they catch a lot more and shrink what's left for you to review
but also maybe in the limit, the bitter lesson will prevail and flawless code will just be printed out perfectly every time with no bugs. even in that scenario, /statechart still seems very helpful in confirming that the agent understood your intent correctly. give it a try if you haven't already!
github.com/cursor/plugins/tr…
33
A side project for my side project:
github.com/soasme/tlaplusplu…
TLA+ needs TLC to run, which needs Java and is so slow.
To run my TLA+ specs faster, I built TLA⁺⁺ (TLA Plus Plus) using C11, no deps.
It cuts the exec time in half for small-python: 320s -> 150s.
#TLAPLUS
Small Python 0.8.0 is out!
Missing Python std lib is no longer a big issue!
`spyc` is able to mix compiling python and static library together like `spyc pycode.py libmymodule.a && ./a.out` (use `import mymodule` in your python code).
github.com/soasme/small-pyth…
Full #Python 3.15 language core + builtins covered and published to PyPI and NPM:
pip install smals-python
npm install small-python
github.com/soasme/small-pyth…
38
Make a minecraft game in Python, and run on X. I swear I am not nut!
soasme.com/small-craft/
Source code: github.com/soasme/small-craf…
Using the newly released Small Python v0.5.0: github.com/soasme/small-pyth…
32
Small Python 0.5.0 is out.
With no bytecode compiler or JIT, it can run with 25% memory comparing to C Python (3MB vs 13MB).
It is also faster on several benchmarks:
0.4x on loops
0.49x on bigint
0.74x on dicts
0.91x on strs
0.94x on classes
github.com/soasme/small-pyth…
42
if you trust my test suite, trust small-python please.
if you're stubborn with code review, sorry, don't use it.
the time has changed.
code review for meat proxies are head.
github.com/soasme/small-pyth…
1
53
Small Python is the evidence: github.com/soasme/small-pyth…
And it is one week, not two weeks.
I'm convinced that at this point, you could have an Opus 5.5 agent re-implement all of CPython probably within two weeks without any human input, against just the tests, and probably with full compatibility with including ABI, no GIL, a jit and probably beat it on all measurable metrics. It's completely crazy.
1
111
I don't use grill-me anymore. Just say "Use your best judgement" to Opus 5.5, with a coding taste skill plus a bunch of basic project specific design rules. It simply works.
/grill-me is my most popular skill ever.
I get 5-10 messages a day about how it’s changed people’s workflows for the better
But… I’ve stopped using it for code. Here’s the improved version:
36
Unless you take the fork approach for every bits of software down the rabbit hole, you're gonna pay. AI makes the fixing easy but people wants someone just to be accountable.
In a hipotetical future of AI being able to instantly fix issues and add new features to any public open source framework/engine, what are the benefits of licensing a commercial private/closed source engine? 🤔
44















