Twinspire Core (currently written in Haxe) has become increasingly complex, with system on top of system, abstraction on top of abstraction. I took a step back and realised this when considering the system I was making.

I've considered going into the C domain and looking at Raylib. I am fluent in C, and although it has eccentricities we all admit is cumbersome to work with, it is still an improvement over the complexities of C++. My aim has always been to write a tool that aids in my ability to make video games as quickly as possible, using the simplest possible approach.

No framework does this, and I embarked on this journey with Twinspire Core - and then made it complex. Complexity creep is a real thing, and Twinspire Core suffers from this a lot.

Therefore, I am returning to the drawing board. This doesn't mean re-writing everything.

Twinspire CoreNative will drastically simplify many existing systems from Twinspire Core - it's just the case of porting most of the code and making it compatible with Raylib. Some differences will be obvious:

• A more data-oriented design
• Easier bootstrapping
• Different language
• Memory arenas and mandatory, explicit memory allocations

Other not so obvious differences:

• GraphicsContext revamp
  • No more dealing with indexes and groups
  • Containers and scrolling familiar
  • Text Input creation familiar
  • Callback system familiar
  • Behaviour system added (new, to replace query modifications and use it as a flagging system instead)
• User Interface revamp
  • This has always been the focus for my plans. UI has always been something I want to solve, and it isn't just about layout systems. Layout systems are great for what they do, but automating events and related user input behaviours is something no one likes to tackle, because they are time consuming and difficult to get right properly. Building UI is "easy", if you want mediocre and typical user input for your target device, but for cross-platform, cross-target support, every single aspect of the UI system must be right, and that's what's difficult.

Some other systems will be familiar and won't go away from the core concepts in Twinspire Core.

The foundations for CoreNative have been built, but it's a long journey to the finish line. I will be working my balls off getting this done as quickly as possible, as it doesn't just stop with CoreNative. My video games come next.

What accelerates the development progress?

Claude AI + Replit has been a powerhouse for development. Replit has become my AI-assisted IDE due to its agency and integrated auto-completion and agentic tools. People call it VIBE coding, but while VIBE coding is more of a niche domain, Replit is an automation service that serves as a full IDE, unlike VIBE environments which are normally just code editors with a "twist" - see Cursor.

Combining this with Claude AI makes production speed so much faster. You could argue that installing Claude Code and setting up agents manually does the same job when integrated with Visual Studio Code or other editors, but there are limitations.

For instance, Claude can't access your debug console, so it can't see if you run into runtime errors or compile time errors, and react accordingly. Replit does.

Claude also can't use agentic previews and enable interactive previews that enable an agent to see and run on previews, reacting to the state accordingly. Replit can.

However, Replit on its own, despite being a powerful companion, is also expensive at large usage. So, if you're considering using it yourself, I would still have Claude besides to assist with large tasks on a subscription model to avoid the hefty costs of the Replit agency service. Personally, Replit is best at web development and design, but for languages like C, use it for the "vibe" experience in combination with Claude.

At the end of the day, Replit uses the same LLM - Claude - so you get the same results whether you're using Claude directly or via Replit.

This is truly the powerhouse of software engineering, and this combination gets results fast.