Definitely looking to make DuckDB pretty core to my Haxe work.
It's the first relational database that lives in all the places Haxe does. Web (via Wasm), Java, C-compatible (Hashlink , Neko, Cpp, Python, Php, Lua(?), Nodejs) , and in-memory (Eval, Macro-time).

#Haxe #DuckDb

Farvel til Flash. Adobe Animate (tidl. Macromedia Flash) udfases pr. 1. marts 2026, hvorefter det ikke er muligt at købe app'en.

Der findes et godt FOSS-alternativ i enten Synfig Studio eller Friction, som begge er stærke på 2D-animation. De mangler dog begge muligheder for, at man kan scripte animationer*, men det kan være, det kommer en dag.

https://www.adobe.com/products/animate.html

Friction: https://friction.graphics
Synfig: https://www.synfig.org

*) scriptede animationer kan f.eks laves med Haxe/Flash: https://haxe.org/manual/target-flash-getting-started.html
OpenFL: https://www.openfl.org/

#opensource #dkopensource #flash #haxe

Circular reference checking gets way out of hand in the Haxe object notation transformer as input sizes increase.

In order to cull it, I'm going to assume that only classes can have self references.

I know it's possible at runtime to break this rule, but you've got to fight the type system to do it, and there's a mechanism already to override the encoder behaviour where this is true.

I tried getting the y-combinator working because I've got to pass config around the equality algorithm so it can do more than one sort of equality, but no luck, there's still a hashlink compilation issue at least.

Might wind up copy pasting the Lookup function to escape the tedium of parameterising all of the Eq instances.

Naming of the now two distinct Eq methods also eludes me.

#DevLog #Haxe

@ableijs @bossito @ploum

Can add:
- #Ocaml (and generally ML lineage)
- #Haxe

Though we collect this nice set of EU-centric OS fame, let's give a pause and hat-tip to the excellent overseas #SQLite and #FossilSCM

Sometimes the visual mistakes can be so cool and so unexpected, after hours of errors and no compile something is always welcome. Had something working, but code was so ugly tried to rebuild. Tried lots of Generics with pain, so half abandoned that.
The filled triangle are now almost the opposite of the aim, so lightly I am close, so something for another day, when feeling fresh!
#haxe #morton #earcut #pre-scanline #holes

Updated my Haxe compiler devpod to support vscodium, now on codeberg.

https://codeberg.org/ohmrun/haxe.compiler.dev

#DevLog #Haxe #Codeberg

One positive thing I can say about AI-assisted coding is that it’s weirdly inspired me to put more work into improving my OSS projects again. Mostly without the help of any such tools so far. My thought process has been that any effort I put into making it easier for people to volunteer to work on it isn’t a complete waste if no one volunteers because at the very least the documentation I provide will make it easier to have opencode use free models (I feel like providers should have free plans for OSS but whatever) to hack away at adding tests and other bullshit that I hate dicking around with. I definitely have a strong preference for deterministic code generation but these nondeterministic tools can assist in speeding up the process of making the DSLs (copilot helped me a little bit with making Haxe macros the other day but ho boy did it hallucinate a lot at first).

My principles for avoiding the ways in which LLMs can exacerbate already unsound development, which I should codify into a document somewhere (and perhaps make visible to agents!) -

• Prefer deterministic code generation to reduce code bloat. Concretely, as an example in the #haxe context, pre-build Macros to generate externs from e.g., python, js or ts code is preferred over code that must be manually run to create .hx files that are checked in, which in turn is preferred over using LLMs to manually create the externs. But even that last one is preferable to making externs by hand.

• Write documentation and instruction for persons. Do not optimize things to get the desired result from LLMs. Models change, but the principles for explaining things to persons remain the same. E.g., efforts to translate docs into multiple languages help persons, but make no difference for LLMs. If you really need agent-specific instructions, throw it into AGENTS.md but ideally that file should just say “see README.md and CONTRIBUTING.md“

• Do not measure success by lines of code! We’re not a big stupid company where higher-ups have no idea what’s going on and use crude metrics for determining head count. The less code needed to complete a task without making the code unclear, the better. LLMs can give a false sense of accomplishment by making a lot of complicated wrapper code that, if you put more thought into it, wasn’t needed. Providers may have a perverse incentive to create more tech debt, which in turn you’ll need to pay for more tokens to maintain.

• Prepare for the rugpull. You should always be prepared to keep going if the agents disappear. Never let your code turn into a black box that you don’t understand anymore. Never forget how to code. Be prepared for when that model stops being free or that other model jumps in price. Be prepared to maintain your code if civilization collapses or the global internet infrastructure breaks. You shouldn’t ever need the cloud to develop a non-cloud application, period. You should always be prepared to hire humans to help you or roll up your own sleeves. OSS succeeds when we do a better job than big tech at keeping our costs down and keeping things simple. Let them saddle themselves with tech debt and don’t repeat their mistakes!

Messing about with Babashka for preparing Gcc invocations. Loops in make files? no thanks.

Even found Fennel, which is a Clojure style lisp ( map + vector literals ) that compiles to Lua, which might let me pull out some of the data from .rockspec files via Edn.

In any case, having got the regex library statically linked into Lua, there are six more libraries I have to add to the build

(and know which defines to use and so on)

Next session I want to see if I can use `juxt/aero` to describe the inputs.

Also found `((requiring-resolve 'malli.dev/start!))` in malli for clearer debug info

#Haxe #Lua #Fennel #Babashka #DevLog

Holy shit it fkn works.

regex library built into a static lua binary.

#Lua #Haxe #DevLog

Okay, might as well make a release! Here's the first release of my #Bitwig extension for APC Key 25 that includes support for the newer version (mk2). Bitwig has built-in support for the newer version too but mine includes additional features and will also start working in other DAWs as well as I add support to the underlying #haxe framework, grig.controller. In the process I also fixed an embarrassing, ancient bug in grig.midi.

https://codeberg.org/grig/apc-key-25-bitwig/releases/tag/1.5

Today I livestreamed about updating my #bitwig controllers, in my #haxe -based framework for targeting multiple DAWs. I’m fixing issues with the original APC Key 25 created by my changes meant to facilitate getting the mkII version working. My goal is to have both working again this week. I was working on this last June then foolishly put it down until now. Bitwig has its own script for mkII but I wanted to bring the features I added - and support for other DAWs - to this newer version of the device.

I have bigger plans for this script, as I discuss in the video. Ultimately, this framework will unlock a lot of potential even for simple hardware such as this and not just for Bitwig, but trackers like #Renoise.

If you want to support me working on this stuff, check out my ko-fi.

https://www.twitch.tv/videos/2662329462

Some brief #haxe dev to assist in me making #WordPress plugins I did today on twitch:

https://www.twitch.tv/videos/2657957626

I have a modest but achievable (I think) goal of going from 0 to 10 paid subscribers on my kofi by end of next month.

This end of year recap comes with an update of the engine: Ceramic 2.1, and it’s new cross-platform shader language.

https://github.com/ceramic-engine/ceramic/releases/tag/v2.1.0

#enginedev #gamedev #indiedev #opensource #haxe

Another year has passed. Let's take a moment to look back at what happened around my game engine Ceramic and what's coming next 👇

https://ceramic-engine.com/blog/bye-2025-hi-2026/

#gamedev #enginedev #indiedev #haxe #unity #solodev

Because the world really needs another planner app... I've just released a new one for free at itch.io:
https://jonaspeheim.itch.io/scatterplan
#solodev #gamedev #haxe #openfl

🛠️ Title: HaxeFlixel
🦊️ What's: A libre library for developing 2D games with the OpenFL and Haxe languages
🏡️ https://haxeflixel.com/
🐣️ https://github.com/HaxeFlixel
🔖 #LinuxGameDev #Library #Haxe
📦️ #Libre
📕️ https://lebottinlinux.vps.a-lec.org/LO.html

🥁️ Update: 6.1.2
⚗️ Signific. vers. 🦍️
📌️ Changes: https://github.com/HaxeFlixel/flixel/blob/dev/CHANGELOG.md
🦣️ From: 🛜️ https://github.com/HaxeFlixel/flixel/releases.atom

🐹️ https://www.youtube.com/embed/0ERcNEg61Lg
🐹️ https://www.youtube.com/embed/7jUKDSL2L6E
🎮️ https://www.youtube.com/embed/3sZokWGYMcI
🎮️ https://www.youtube.com/embed/wVmax3XesjQ
🎮️ https://www.youtube.com/embed/_2YqmbaKqv0

Seven days into this #AdventOfCode as primarily a #Haxe programmer, I'm quite annoyed that five of the puzzles so far have required me to use Int64, which is not as smooth of a process in Haxe as it is in other languages. I guess I should just assume I need to provide my answer in Int64 going forward, even if it doesn't look like it's necessary to do so.

I got as far as just passing the arguments straight through
```bash
bb -m zoot/apply --run Test
```
is effectively
```bash
haxe --run Test
```

noice.

#Haxe

Found `process/exec` today, which means I can run babashka, accumulate arguments for the haxe compiler, and have the babashka script replace it's own process with a call to haxe, as if I'd called haxe directly.

#Haxe