United Airlines
Boeing 777-224(ER)
#UA #UAL #UNITED
#Boeing #B777 #N78003
#aviationphotography
#bnw #bnw_aviation #lowkey
January 06, 2026 at 01:45AM
via Instagram https://instagr.am/p/DTItxdcES_m/
#UAL
ual v0.7.5 released
ual is a systems language for orchestration and embedded computation. It now comes in three forms: two compilers (Go and Rust backends) and an interpreter. All three share the same semantics and produce identical results. This release adds a production-ready Rust backend and a threaded-code compiler for the interpreter.
What's new
Rust backend with full feature parity — 92/92 examples produce identical output across Go, Rust, and interpreter. Rust binaries are 4× smaller (343K vs 1.3M stripped).
Threaded-code compiler for iual delivers 5–12× speedup on numeric workloads. The interpreter now beats Python by 4–13× while remaining a single-file tool for development.
Automatic target selection: if you have Go, it uses Go. If you only have Rust, it uses Rust. Write once, compile anywhere.
What makes ual different
Coordination is the primary problem; computation happens in designated islands. Data lives in typed stacks accessed through perspectives (LIFO, FIFO, Indexed, Hash). Time is explicit. Errors must be acknowledged.
Binaries available for:
Linux (amd64, arm64, arm, 386), macOS (Intel, Apple Silicon), Windows (64-bit, 32-bit), FreeBSD, OpenBSD, NetBSD
Release:
https://github.com/ha1tch/ual/releases/tag/v0.7.5
Docs:
https://github.com/ha1tch/ual/blob/main/docs/MANUAL.md
#ual #golang #foss #rust #rustlang #forth #programming #compsci
ual v0.7.5 released
ual is a systems language for orchestration and embedded computation. It now comes in three forms: two compilers (Go and Rust backends) and an interpreter. All three share the same semantics and produce identical results. This release adds a production-ready Rust backend and a threaded-code compiler for the interpreter.
What's new
Rust backend with full feature parity — 92/92 examples produce identical output across Go, Rust, and interpreter. Rust binaries are 4× smaller (343K vs 1.3M stripped).
Threaded-code compiler for iual delivers 5–12× speedup on numeric workloads. The interpreter now beats Python by 4–13× while remaining a single-file tool for development.
Automatic target selection: if you have Go, it uses Go. If you only have Rust, it uses Rust. Write once, compile anywhere.
What makes ual different
Coordination is the primary problem; computation happens in designated islands. Data lives in typed stacks accessed through perspectives (LIFO, FIFO, Indexed, Hash). Time is explicit. Errors must be acknowledged.
Binaries available for:
Linux (amd64, arm64, arm, 386), macOS (Intel, Apple Silicon), Windows (64-bit, 32-bit), FreeBSD, OpenBSD, NetBSD
Release:
https://github.com/ha1tch/ual/releases/tag/v0.7.5
Docs:
https://github.com/ha1tch/ual/blob/main/docs/MANUAL.md
#ual #golang #foss #rust #rustlang #forth #programming #compsci
ual 0.7.5 benchmarks
You may run your own with:
$ make benchmark
I noticed substantial disparities between my favourite M1 laptop and Linux servers on x64, but ual was never slower than Python and the differences between the native binary backends is unnoticeable most of the time.
I'll be running more tests on other systems during the weekend.
(on a Ryzen 5 laptop, and maybe Raspberry Pi 3b, to broaden the test base)
#ual #programming #compsci #rust #rustlang #golang #forth #foss
Some high level comparisons of the three ual backends for the upcoming 0.7.4 release.
!📊 With charts!
ual compiled to binary using the Go backend
ual compiled to binary using the Rust backend
iual, the ual interpreter written in Go
#ual #rust #golang #foss #rustlang #forth #compsci #programming
Oh wow! The threaded code approach has made iual's compute blocks faster than Python across all compute-heavy benchmarks, and nearly as fast as C for some workloads. This is without implementing a full bytecode VM, just by pre-compiling the AST of compute-heavy blocks to closures with direct slot access.
Of course this is not a vast variety of algorithms, but the results are incredible, for a quick optimisation that doesn't implement a VM!
I only flattened the AST into an array of closures for every while loop, and these are the results!
I'm very satisfied and I can now go back to sleep 🙂
These ual benchmarks I ran show the limits of the ual interpreter implemented as a simple AST walker. It still performs better than Python on most tasks except in compact compute blocks. In such cases, and cases similar to the Leibniz Pi implementation, Python's optimised bytecode does a far better job.
I don't think it's a good idea to dedicate further resources to the engineering of the interpreter, but short of going full bytecode VM (beyond the scope of my efforts) I can still try to implement direct threading for compact compute blocks. That might work!
Obviously, this doesn't affect compiled ual using the Go and Rust backends, but I still would like to offer the interpreter for development testing, and I would like it to be at least competent enough to perform similarly to Python for most tasks.
#ual #foss #golang #rust #rustlang #forth #compsci #programming
ual 0.7.4 preliminar benchmarks
Some early ual 0.7.4 benchmarking results across three backends: compiled with Go runtime, compiled with Rust runtime (rual), interpreted (iual).
No attempt has been made to make the new backends faster yet (iual, rual). That being said most concurrent code performs similarly across all three backends, and only interpreted ual (tree walker) sees an obvious penalty in compute heavy algorithms. I might --maaaybee-- be able to provide a VM for iual, but given the performance of the binaries using the Go and Rust backends it seems that it would be a better use of my time to keep adding important features that are still missing in this version. (file handling, sockets, for starters).
It seems to me that the ideal ual developer of the future will be happy to use iual for testing, and deliverable products will be compiled with one of the binary backend targets. The choice of Go or Rust will probably go down to environmental reasons, cultural aspects, or policy preference within organisations.
All in all, a highly productive day!
Now thinking of a fourth backend... wouldn't you guess what is it? 🙂
Breakthrough. Three-way parity achieved in upcoming ual 0.7.4 release.
All three backends exhibit identical behaviour across all existing code examples.
Working on a new code generator for ual 0.7.4 that generates Rust instead of Go.
So the ual compiler now has two new command line switches to indicate which backend you want to use:
--target go
--target rust
Experiments show that generated binaries using a Rust runtime and Rust as the IR result in binaries of about 400k on average for the bundled code examples. That's significantly smaller than the Go-generated binaries somewhere between 1.8 Mb and 2.8 Mb.
I'm also adding a few other switches that control both language backends:
--release
--debug
--small
ual v0.7.3 released
ual is a systems language for orchestration and embedded computation. It comes in two forms: a compiler targeting native binaries, and an interpreter for development. Both share the same runtime and produce identical results. This release marks the completion of runtime unification — the interpreter now has full parity with the compiler, including true goroutine-based concurrency, using Go as IR and bootstrapping tool.
What makes ual different
ual is built on a specific philosophical foundation: that coordination is the primary problem of programming and that types and computation are subordinate within coordinated contexts. Data lives in typed stacks accessed through perspectives (LIFO, FIFO, Indexed, Hash). Time is explicit — blocking waits, timeouts are native. Errors must be acknowledged before proceeding.
Binaries available for:
Linux (amd64, arm64, arm, 386), macOS (Intel, Apple Silicon), Windows (64-bit, 32-bit), FreeBSD, OpenBSD, NetBSD
Release:
https://github.com/ha1tch/ual/releases/tag/v0.7.3
Docs
https://github.com/ha1tch/ual/blob/main/docs/MANUAL.md
#ual #golang #foss #rust #rustlang #forth #programming #compsci
So this is what concurrency looks like now in the new ual language.
And it doesn't hurt to add ual syntax highlighting to bim, the barely improved editor! 🙂
#bim #ual #programming #language #uallang #golang #foss #forth #rust #rustlang #compsci
the ual programming language
After nine months without updates, I'm feeling more confident to share publicly how ual is doing and where ual may be going next. There will be some substantial changes from the specs I've been publishing, the language has evolved in some interesting ways, but I think the most surprising part of the news you want to hear may be this: it works, I have a working compiler, and it's performing very, very well.
I've added a new feature to the language that enables ualc (the new ual compiler) to translate computation logic down to the most performant possible code that can be optimised by the Go compiler, using Go's runtime, and the Go language as my IR language. Many successful cases exist of languages that started this way, and it has proven an efficient and relatively painless way to bootstrap.
Another two versions of the ual compiler called rualc and tualc are on the drawing board (the former targeting Rust, the latter targeting TinyGo).
See attached some preliminary results of the compute intensive execution paths I'm working on right now.
#ual #rust #rustlang #golang #foss #programming #compsci #forth
After all these little detours I think it's fair that I return for a while to everyone's favourite:
the ual programming language
hahaha, not really anybody's favourite but it's at least a favourite of mine
I don't care what you say about United Airlines they are good people #UAL #United #UnitedAirlines #compassion #widow
#Almeria #UAL Conferencia San Alberto: ¿Por qué me dicen que llego tarde si no existe el tiempo? La física del tiempo? Viernes, 14 nov 12:15. Organizada por la Facultad de Ciencias Experimentales Universidad de Almería. https://agenda.ual.es/eventos/por-que-me-dicen-que-llego-tarde-si-no-existe-e-tiempo-la-fisica-del-tiempo/
#Almeria #UAL Conferencia San Alberto: ¿Por qué me dicen que llego tarde si no existe el tiempo? La física del tiempo? Viernes, 14 nov 12:15. Organizada por la Facultad de Ciencias Experimentales Universidad de Almería. agenda.ual.es/eventos/por-...
¿Por qué me dicen que llego ta...
Meteor or space debris? We will know soon. https://www.wired.com/story/mystery-space-object-strikes-united-airlines-flight-over-utah/ #UnitedAirlines #Aircraft #SpaceDebris #Meteor #NTSB #UAL
Client Info
Server: https://mastodon.social
Version: 2025.07
Repository: https://github.com/cyevgeniy/lmst