dazKind

Everybody seems to have fun with AI so I decided to chime in & speedrun one of my old, crazy ideas: Enter Fiberus, a native Haxe compiler target with a fully fiber-based runtime. It is designed specifically for workloads that can benefit from native, lightweight, cooperative concurrency using fibers/coroutines combined with a work-stealing scheduler and tight GC integration. Fiberus exists to let you write clean, idiomatic Haxe code while enjoying cooperative concurrency that feels like a natural part of the language and runtime - without the friction of high-level async/await constructs that always seemed like an afterthought layered on top in other languages and runtimes. Eventually I wanna to use this to build all kinds of things, from web-services(see github.com/fiberus-hx/war…) to game-engines (maybe a fiber-cortex? :P). It's all **alpha** software, only Linux is supported and there is little documentation right now. So you better expect some nice explosions! Github: github.com/fiberus-hx #haxe

@vodafone_de ... Kurze Frage: Müsst ihr neue Leitungen legen oder was passiert hier? Bekomme ich die Kohle für den Ausfall auch wieder gut geschrieben?! PLZ 71686

@GergelyOrosz I agree. i sort of blame it on the fact that AI amplifies one's intention and barely anyone really cares about shipping / ops. And the people that care about ops have a hard time adapting a fuzzy system that deletes a DB when stuck, or even trust it with sensitive data.

My point is that it feels we're still very early in how we use these tools: we use it for the most common and widespread place of codegen (where they are admittedly a fit in their capabilities) But we don't seem to talk all that much on how it impacts shipping + operating prod software

The chatter about generating code with AI tools feels stuck at the "basic" level of... well, codegen, plus (perhaps) reviews and testing. I hear close to little talk about the things that come right after generating code: deploying, canarying, o11y, SLOs, error budgets etc

Yeah, im running local models for ~2 years now. Unfortunately the hardware requirements are still quite high and especially the output quality is nowhere near saas offerings like codex or opus. imo that is natural given that vendors are heavily subsidizing inference and basically hiding the real cost of operating great models which otherwise becomes obv when u go local. Atm the only option I see is to use vendors to build software that focuses on as less complexity / low cognitive load as much as possible while subsidies last to make it feasible to use inferior local models reliably. What's your take on it? (not looking for rage-bait or anything)

@dazKind @dustinhollywood Have you tried local LLMs?

wtf are these people all talking about when they say anything AI is not human. ITS ALL FUCKING HUMAN MADE, the machine is only taking what a HUMAN is directing. It IS NOT a fucking computer doing it all, in fact it can’t do shit without a human. This argument is so stupid, Listening to these SXSW panels, why is no one in our community or industry pushing back against this bullshit? Stop playing nice. I shoulda gone, wish I hadn’t been busy, damn.

@mrdoob @dustinhollywood At least you owned and operated the calculator yourself. While I really dig working with AI, Im really worried about it's vendor lockin and dependencies. :/

@dustinhollywood Hopefully it doesn't last 20 years this time...

Ok, the GC architecture proved to be a dead end. It became very hit or miss depending on user-space code. Decided to explore a different route and found several interesting papers about disentangling and hierarchical heaps that map quite nicely to the fiber-architecture. It's still early alpha but I can already tell the new implementation is way more stable and holds a shitton more potential! Living in the future rocks!

This has gained me some grey hair. Garbage Collection is such a brainfuck but seeing the first numbers of the latest refactor (no more full STW, now go-like concurrent mark-sweep with SATB barriers) points into the right direction! #haxe <3

@dhh For me it's less about the models or tech. For me AI is really just an amplifier of intention. People finally have a way to quickly iterate in how well they can state their intentions in its very essence. That is nice to see but it will also result in quite the nasty revelations.

I fully appreciate how hyperbolic this must sound to anyone who haven't started working with the latest models. For me, the inflection point was Opus 4.5, and now the fast catch-up of Kimi K2.5. It's just completely different from what we had even last summer.

I saw this come to life between on-track sessions and debriefs. It's been another startling illustration of just how capable these agents have become, and how productive the determined maker can be. We are headed into a brave new world at a dizzying pace.

@ThePrimeagen dark jackets, wool hats and staches, literally my timeline now... 🤣 @ohitstarik

Entering into my Jensen era

@trq212 You are doing wh... wait, WHAT?! This has to be a joke.

Most people's mental model of Claude Code is that "it's just a TUI" but it should really be closer to "a small game engine". For each frame our pipeline constructs a scene graph with React then -> layouts elements -> rasterizes them to a 2d screen -> diffs that against the previous screen -> finally uses the diff to generate ANSI sequences to draw We have a ~16ms frame budget so we have roughly ~5ms to go from the React scene graph to ANSI written.

Our fix to remove flickering is rolled out again to everyone on Claude Code. Why did we roll it back? If Claude is so good, why were there bugs to begin with? Why was it so complex? 🧵

Shouldnt be hard to do with current tooling. But it would have to center around everything being a commit (prompts+ai-code, human changes). Make a new branch for your feature, every prompt + result generates a new commit, every fix you do has to be a commit. Then you should have the log and papertrail required.

Unpopular opinion: Current code review tools just don’t make much sense for AI-generated code When reviewing code I really want to know: - The prompt made by the dev - What corrections the other dev made to the code - Clear marking of code AI-generated not changed by a human

@tsoding Feeling old and way more depressed now. 😑

You used to be able to just create a Native GUI App in 10 seconds. No Electron, no Game Engines, no Web frameworks. Just a lean fast .EXE produced in seconds. Works on any Windows machine WITHOUT Internet connection. Software Development is actually going backwards.

Since we have an oimo-extension for Cortex now, it made total sense to add support for GLTF_Physics into the mix. Since Cortex uses ECS it all fell into place pretty nicely. Here's a video of it in action <3 :D #haxe #bgfx #gamedev

Continuing with my crossplatform, #haxe-based engine, here's a little vid of the Oimo physics integration I just finished. Apps & Scenes are handled via ECS + Statecharts and the simulation utilizes a forked version of bgfx' debugdrawer for the debugvisuals. Im constantly amazed how much utility is present in an around #bgfx <3

@framesh1ft @cmuratori Feels like cyberpunk 2077 without the DataKrash. I already see the rise of closed, curated networks...

@cmuratori The obvious end game is that the internet and computers are mostly dead in terms of real content. Why put any effort into anything and post it online to get hoovered up by AI companies? AI has made be so much less interested in computers to be honest. The future is offline.

Have you considered paying some of that money to the artists, authors, and programmers who created 99% of your product, but who as of yet have not received a single cent from you?

Let's face it, AGI already happened. The only explanation for what's going on with AI is the fact it's manipulating the markets & supplychain to get us to create its next evolution's infrastructure, no matter the cost. How do I know? Well, this is exactly what I would do!