caspar

This is partially a "how much does the model follow instructions" thing. I use Pi with a vibed LSP extension and Claude (4.6 or thereabouts) almost never followed instructions to use LSP renaming tools - despite it being strongly emphasized in system prompt and agents.md. However I found Codex 5.3 would use them sometimes, and GPT 5.4/5.5 would prefer them.

Try vidir from moreutils (or its improved version, https://github.com/bulletmark/edir ).

It opens the list of filenames in a given directory (or set of files passed on cmdline) in an editor of your choice, and then you use your editor to rename them; the changes get applied when your editor is closed.

There was/is a patch available that lifted the unit limit significantly. I played with it constantly. Even played a match at a lan party with friends last year.

Well language detection isn't all that hard in the scheme of things (especially now), but maybe having only training on English makes models less effective programmers. It would be interesting to see that as an experiment.

An internet comment communicating the death of communication on the internet - how wonderfully paradoxical!

(or if you tasked an AI to write that: how appropriate!)

This is also what I've done for my multiplayer falling sand game: it's very much not vibe coded (too performance-sensitive), but coding agents can launch the game on my steamdeck and run benchmarks, take captures & verify rendering is bit-for-bit identical on a given machine, etc.

Agent can't _play_ the game yet, but that's on my list to experiment with.

2x2 pixel font is probably impossible[1], but with a few more pixels of width someone made a surprisingly readable 2-pixel-high font: https://www.reddit.com/r/PixelArt/comments/1myh81x/2px_high_...

Released by the author at https://joefatula.com/twoslice.html

[1]: unless you use multiple glyphs for a char. Or maybe it'd be possible to interpret if the glyph-to-char mapping pattern was very carefully thought out..

Not the OP but here is a good example: https://mariozechner.at/posts/2025-11-30-pi-coding-agent/

Initially I read it because just it was interesting but it has ended up being the harness I have stuck with - pi is well designed, nicely extensible and supports many model provider APIs. Though sadly gemini and claude's subscriptions can't really be used with it anymore thanks to openclaw.

Really?

I've been a fulltime Linux user for years but there are tons of excellent Windows-only apps.

Here are some that I miss: Directory Opus, ShareX, Wiztree, Everything, AltDrag, AutoHotkey, Paint.NET, irfanview, SumatraPDF. I'd add Keepass2 as well but fortunately KeepassXC is a thing.

Those are all feature-filled (in the bloat-free good way) and they've all been around for over a decade (from memory). Most are free and open source to boot.

I've been struggling to sell it ... they will value a one-shotted pretty UI over all these other aspects.

I do not think that it's your competitors' pretty one-shotted UIs that are losing you your leads. FWIW your website:

  * Does not explain the benefits nor the feature-set of what your platform offers
  * Has a Docs page which seems to be a link to 6 sets of reference APIs (or similar) in disparate Github pages - that's worse than most open source products.
  * Uses cute animated characters which does not give off the "we are a serious enterprise and you can rely on us" vibe
  * Has a novel pricing scheme ("implements a techno-feudalist pricing model") that requires a 4 paragraph explanation and somehow tries to frame introducing additional uncertainty for potential buyers as a feature (it's a good thing that _my_ pricing tiers could be adjusted by other customers' votes!?)
  * Additionally prominently features cryptocurrency in the topnav, which is for many people a yellow or red flag (regardless of what seems to be your good intentions behind it)
 Doesn't have any demo apps I can click around in to smoke test the platform's functionality, let alone fiddle with the backend
  * Has almost zero information on basic business-y compliance-y things - no info on security, availability, SSO support, etc let alone more hardcore things like compliance standards your platform meets.

Noita uses herringbone wang tiles where each wang tile pixel is 16x16 simulated in-game CA pixels, with tiles selected from a per-biome pool and the ability for biome-specific scripts to override certain areas too. As part of expanding each wang tile pixel into 16x16 pixels, some noise is applied to terrain to add the curvy look, with another layer of (thresholded perlin?) noise that controls which bits of inner terrain get variations (gold veins etc).

Source: working on a Noita-like so have spent a bit of time looking at prior art. Noita wiki.gg will explain a lot of it though (warning: many spoilers).

for anyone reading this later, claude code's sandbox code is at https://github.com/anthropic-experimental/sandbox-runtime/

I haven't used opencode but pi agent runs rings around claude code. Never eats tons of CPU on big outputs, no flickering, open source, tree-based context instead of claude's linear context, easy to toggle collapsing/expanding tool outputs, built for extension with runtime reloading of extensions and skills, etc. You can easily build your own amp-code like handoff mechanism, customize the UI (i see models' edit diffs syntax-highlighted with delta, and just added a keybind to list session-edited files + files from git status in fzf), etc.

Meanwhile with Claude Code I've had to get claude to decompile the editor (extract JS from the bun executable) _twice_ to diagnose weird things like why some documented config flags were not taking effect.

Opus is great - but I'd rather use a different model than be forced back into Claude Code.

Well, sometimes your compiler will work out how to more efficiently compile a thing (e.g. vectorize a loop), and other times you'll rework some code to an equivalent formulation and suddenly it won't get vectorized because you've tripped some invisible flag that prevents an inlining operation that was crucial to enabling that vectorization, and now that hot path runs at a quarter of the speed it did before.

Technically it's (usually) deterministic for a given input, and you can follow various best practices to increase your odds of triggering the right optimizations.

But practically speaking "will I get the good & fast code for this formulation" is a crap shoot, and something like 99% (99.99%?) of programmers live with that. (you have guidelines and best practices you can follow, kinda like steering agents, but rarely get guarantees)

Maybe in the future the vast majority of programmers put up with a non-deterministic & variable amount of correctness in their programs, similar to how most of us put up with a (in practice) non-deterministic & variable amount of performance in our programs now?

Not strictly true afaik? If you own the copyright to the entire codebase you can relicense at will to a different license. (that's what CLAs enable among other things)

Not sure whether you'd still be entitled to the source code under the previous license then.. can a copyright owner revoke a previously issued license to the code? Haven't heard of it, but wouldn't surprise me if it's legal.

Presumably others will write the prompts (or equivalent directing mechanism) that will steer the generation, such that you can act out whatever fantasies interest you.

Likely a separate issue, but I also have massive slowdowns whenever the agent manages to read a particularly long line from a grep or similar (as in, multiple seconds before characters I type actually appear, and sometimes it's difficult to get claude code to register any keypresses at all).

Suspect it's because their "60 frames a second" layout logic is trying to render extremely long lines, maybe with some kind of wrapping being unnecessarily applied. Could obviously just trim the rendered output after the first, I dunno, 1000 characters in a line, but apparently nobody has had time to ask claude code to patch itself to do that.

FYI the sandbox feature is not fully baked and does not seem to be high priority.

For example, for the last 3 weeks using the sandbox on Linux will almost-always litter your repo root with a bunch of write-protected trash files[0] - there are 2 PRs open to fix it, but Anthropic employees have so far entirely ignored both the issue and the PRs.

Very frustrating, since models sometimes accidentally commit those files, so you have to add a bunch of junk to your gitignore. And with claude code being closed source and distributed as a bun standalone executable it's difficult to patch the bug yourself.

[0] https://github.com/anthropic-experimental/sandbox-runtime/is...

I think state of the art LLMs would pass the Turing test for 95% people if those people could (text) chat to them in a time before LLM chatbots became widespread.

That is, the main thing that makes it possible to tell LLM bots apart from humans is that lots of us have over the past 3 years become highly attuned to specific foibles and text patterns which signal LLM generated text - much like how I can tell my close friends' writing apart by their use of vocabulary, punctuation, typical conversation topics, and evidence (or lack) of knowledge in certain domains.

+1 for Maestral, have been using it for about a year on my Linux install and it works seamlessly.

Unity is Unreal Engine's biggest competitor by far. Godot competes with Unity (mostly for 2D games) but is at least a decade off being any threat to Unreal.

So yes, funding Godot is A Nice Thing To Do but it also conveniently puts a bit of pressure on Unity, their biggest competitor, without impacting their own business.

Also, if you believe Matthew Ball's take[0] then Epic is all-in on fostering as many gamedev-ish creators as it can so that it can loop them all into making content for its metaverse later. As you alluded to, in the long term funding a FOSS game engine which is focused on ease of use helps that too.

[0] https://www.matthewball.co/all/epicgamesprimermaster

I can vouch for this "study plan".

4 years ago I tackled exactly those courses (raytracer[0] first, then CPU rasterizer[1]) to learn the basics. And then, yes, I picked up a lib that's a thin wrapper around OpenGL (macroquad) and learned the basics of shaders.

So far this has been enough to build my prototype of a multiplayer Noita-like, with radiance-cascades-powered lighting. Still haven't learned Vulkan or WebGPU properly, though am now considering porting my game to the latter to get some modern niceties.

[0] https://github.com/caspark/the-all-seeing-crab [1]: https://github.com/caspark/little-crab-tv

Certainly if you take it in combination with his earlier "Intel is listening" blog post: https://www.brendangregg.com/blog/2025-11-22/intel-is-listen...

A multiplayer falling sand game - kinda like Noita, but faster paced and online & couch co-op - which happens to run on both desktop and in the browser (including online multiplayer, powered by webrtc data channels).

I have a lot of devlogs at https://www.slowrush.dev/news though at this point I am quite behind showing off the latest graphical improvements there.

Here is some more up-to-date gameplay footage: https://bsky.app/profile/slow-rush.bsky.social/post/3m523ft2...

Been using syncthing with keepass(X/XC) for probably half a decade now and it works great, especially since KeepassXC has a great built-in merge feature for the rare cases that you get conflicts from modifying your vault on different clients before they sync.

The only major point of friction with syncthing is that you should designate one almost-always-on device as "introducer" for every single one of your devices, so that it will tell all your devices whenever it learns about a new device. Otherwise whenever you gain a device (or reinstall etc) then you have to go to N devices to add your new device there.

Oh, and you can't use syncthing to replicate things between two dirs on the same computer - which isn't a big deal for the keepass usecase and arguably is more of a rsync+cron task anyway but good to be aware of.

Dithering means fading away the banding that occurs when the palette (or the apparent palette achieved via halftone) isn't large enough to avoid banding on its own.

Here[0] is a good summary of dithering/noise to reduce color banding. Interestingly, for my game[1] I found that Valve's animated dithering technique (which uses variation over time in lieu of a fixed noise pattern) worked best, as the other techniques described there altered the perceived lightness of the resulting image.

[0] https://blog.frost.kiwi/GLSL-noise-and-radial-gradient/

[1]: A multiplayer Noita-like (more at https://slowrush.dev), where the radiance-cascades-powered lighting tends to cause obvious banding patterns on really dark backgrounds.

Another major caveat is that JJ doesn't work with Git LFS yet - though some progress is being made: https://github.com/jj-vcs/jj/issues/80

If you are used to PRs taking days (or over a week!) to merge, then I've found it's way faster to get someone to sit down and walk them through the code - which is not miles different from what's being proposed here.

Stash was not an acquisition. Stash was built from the ground up inside Atlassian during its golden age, by a bunch of engineers who really cared about performance. Though it helped that they didn't have Jira's 'problem' of having 8 figures of revenue hanging off a terrible database schema designed a decade ago.

You might be thinking of Fisheye/Crucible, which were acquisitions, and suffered the traditional fate of being sidelined.

(You are 100% correct that Stash/Bitbucket Server has also been sidelined, but that has everything to do with their cloud SaaS model generating more revenue than selling self-hosted licenses. The last time I used it circa 2024, it was still way faster than Bitbucket Cloud though.)

Source: worked at Atlassian for a long time but left a few years ago.

GP suggested 200k over 4 years, which is pretty reasonable.