Norway now has more than 2,000 underwater AI laser robots shooting lice off its salmon
they're made by a company called Stingray, and they already guard more than 50 million salmon and trout 24/7
the reason is sea lice, tiny parasites that latch onto salmon and feed on them
as few as 11 can kill a small fish, and one pen can hold 150,000 salmon
the usual fix is pumping the fish out and blasting them with warm water or water jets to knock the lice off
but the handling is so rough that Norway's fish health report ranks it the top cause of death in full-grown farmed salmon
so instead, Stingray puts a robot inside the pen that hunts lice one at a time, all day:
> two cameras watch every salmon that swims past
> AI checks two frames to make sure it's really a louse
> then a green laser fires from up to 2 meters away
> the salmon's scales reflect the beam, so the fish swims off fine and the louse is dead
we now live in a world where AI lasers do pest control on your dinner lmao
Architecture. The set of significant design decisions that shape the form and function of a system.
What Bob calls “the high level gestalt of the system” is what I call its architecture.
And for a software-intensive system, architecture has always been far more important than any details of its implementation.
Five months ago, we were a new player, very small, and none of us had done large-scale pretraining like the frontier labs. Today Canva Craft is #4 on @DesignArena, ahead of every lab except @OpenAI, with a fraction of the para. and data. 0 to 1 in five months. Really proud!
Canva Craft, the first ever image model by @canva, takes the #4 spot on DesignArena's Image leaderboard. This makes Canva the #2 Image Lab after @OpenAI!
Notably, it wins most often on photorealistic product and object shots, setting up studio-style lighting and detailed material textures on a single hero object. It also ranks #1 on the Portrait and Landscape subcategories.
Congrats to the @canva team on the launch!
So I joined this mob just on 2 years ago, and what a ride. I'm building some cool video/rendering tech, meanwhile our ML folks have been busy building models that are right up there with the best in the world. Great time to be alive!
Introducing Canva Craft 🚀
Extraordinary image generation is now available to everyone, powered by our first frontier model built specifically for design.
With Craft, Canva is now the world's second most advanced AI lab for image generation on @DesignArena's global leaderboard.
See what it can do 👇
After six years in stealth, Atomic Machines is out. Our mission: on-demand, universal command of matter. First beachhead: the Matter Compiler, an AI-native manufacturing system that builds working micro-machines from code alone. No per-product tooling. No process development. Different code, different machine.
What's nice about this is it can emit C for the final compile and produce a memory safe executable. C was always just a high level assembly language and that's how you should use it. If you understand how computers work you understand how C works, there's no magic involved at all
Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.
It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.
github.com/aardappel/goose
1/
This man is no goose (sorry for the pun). Check this out folks, if you want to try a truly new language that is sure to be fun to play with, oh, and super fast as well!
Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.
It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.
github.com/aardappel/goose
1/
Compiler can only do so much. Modern software is often bottlenecked by memory access. Compiler is not allowed to change your data layout in memory. It can’t get rid of cache misses. Idiomatic way of writing some languages leads go pointer soups (= lots of cache misses).
There's a lot of talk about software factories right now. Frankly, most of it is bullshit.
Beware “I do AI better than you" snake oil and think more from first principles. Strip most of them back, and you find a series of automations, and one of them happens to be a coding agent. (Which is also what CI/CD was. You stopped clicking around testing by hand, and a machine did it.)
There’s a lot right with making your idea → ship loop continually faster and smarter, but I’m not sure that’s really a new idea.
Nobody starts with a factory.
A chocolate factory starts as one person and some beans in a kitchen, hand-making chocolate. Then they get a mixer. A bigger fridge. A conveyor belt. Then a packaging machine. Each addition builds scale, consistency and efficiency. A small business becomes a medium business, which becomes a factory.
What changes along the way? Where the person stands. What the person does and the technology they can access. First, they do every step. They buy a machine or two. Then they do some steps and watch the machines. Then they operate and connect the machines. Then they redesign the factory itself.
Software is the same loop. Ideas are dreamed up, feedback and operational bugs come in, someone turns them into a list of work items, someone builds it, someone reviews it, someone builds it, someone deploys it, it ships, something breaks, someone notices, someone files the bug. Rinse. Repeat. You've run that for years with a person at every station.
To improve the factory you already have, upgrade one station today. Add automations and AI agents to code or review. Observe, learn. Then do the next one. Thoughtful, ambitious, patient scale.
Are there roles for humans in that factory? Abso-bloody-lutely. Initiating ideas, observing the operation, reviewing at discrete checkpoints or severities, co-designing both the flowed work and the factory itself, owning exceptions and resolving conflicts, adding context. (Just look at one of our latest Loom action plans demo👇🏻 for an example of human-AI collaboration)
I believe this human judgement and intuition only get more important as factory throughput scales.
In short - don’t believe in the mythical agent month. You already have a software factory. AI just allows you to make more steps repeatable, more flexible - and that lets you move where you stand.
SaRCAsm is now powerful enough to compile OpenSSL's X86_64 assembly.
It's a world first: memory-safe constant-time crypto.
Here's my clanker's report:
The final gate is fully green. The task is complete — everything is committed at HEAD 498c3a6 (branch deluge), working tree clean, and the entire flow validated end-to-end in a 1h27m full ./build_all_glibc.sh run.
## Final Report: OpenSSL 3.6.4 with assembly compiled memory-safely through sarcasm
### Outcome
- OpenSSL 3.6.4 test suite: Files=352, Tests=4561, Result: PASS — identical to the no-asm baseline, with the asm dispatch paths (AES-NI/SHA-NI/AVX2/AVX512/IFMA) proven live by sabotage testing. Verified standalone and inside the full glibc build gate.
- Fil-C full test suite: 6285 tests, SUCCESS (sarcasm tests grew 907 → 1044; 2 pre-existing platform skips).
- All 43 x86_64 perlasm outputs compile through sarcasm (padlock excluded via no-padlockeng — VIA-only engine with unmodelable implicit-memory instructions; uplink is Windows-only), and every one was runtime-verified against independent vectors (FIPS-197, RFC 8439, SHA-1/256/512, SHA3, GHASH/GCM, Poly1305, P-256/X25519 field+point math, Montgomery/RSA-Z against python references — sarcasm output is bit-identical to native hardware).
### What was built
Sarcasm features (all with filc/tests regression tests): global variables (same-file data objects mirroring clang's pizlonatedDO_ layout + extern #! global ptr getter calls), local functions (per-caller cloning with −8 return-address compensation, mid-label/loop regions, nested calls), alloca extensions (fixed/dynamic/aligned regions with direct+indexed redirect, phantom SP flows), fast-CC stack words (>4-word signatures incl. SysV stack-arg remapping), .byte decoding + pattern decoder, cross-function jumps (B1 → call+epilogue; B2 → shared-tail cloning; alias entries), #! funcref, .section .init, mid-function SP adjustments, instruction modeling (high-byte regs, movbe, SHA-NI, AVX512 {k}-masked, hi-vec/opmask FP saves), scalability fix (fail-stub liveness clique: 75GB OOM → 7.4GB on the 136K-line file), and ~12 correctness fixes (partial-register liveness, flagDef mangling, ptrflow swap widening, …).
OpenSSL perlasm: #! annotations throughout (gas-compatible — machine-code equivalence proven), central signature injection + byte-emitter neutralization in x86_64-xlate.pl, per-generator region/ptr annotations and gated structural fixes (page-walk removal, xchg-rsp, rolling-window avx2 → avx delegation, cross-object pointer idioms, unaligned-access paths).
Inline asm disabled (guarded, as permitted — only 2 instances): bn/asm/x86_64-gcc.c (uses bn_asm.c under __FILC__; unsupported constraints/pointer args) and DES rorl (C fallback under __FILC__).
Build integration: build_openssl364.sh (asm enabled, no -yolo-assembler, no-padlockeng) wired into build_all_slow.sh; Configure skips -Wa under sarcasm. OpenSSL 3.5.7 remains untouched in pizfix.
This removes the need for the zunsafe_call mechanism for OpenSSL — the assembly is now itself memory-safe, linked naturally with Fil-C code.
Irony: back when I was making a bunch of videos at Google I proposed an auto-scrolling teleprompter using speech recognition to make videos with and it was rejected by the powers that be. Now it ships on the Pixel 11 by default. Typical
New Fil-C release 0.682!
Now with ARM64 binaries (beta quality - only for systems with 4KB page size).
Also includes a bunch of other fixes.
Thank you pcc and twilligon for contributing ARM64 support!
github.com/pizlonator/fil-c/…