Twinspire

Twinspire is an on-going open source application framework written in a variety of languages, the most complete of which is written in C#.

Twinspire started out development in Haxe with Kha, but over time the underlying toolkit was changed over to Raylib, due to its simplicity and far greater feature set.

Features

• A standard application and resource management system (Haxe, C# & ODIN)
• Package Management system for assets (C# only)
• A low-level animation toolset (Haxe, C# & ODIN)
• HotKey system (C# only)

Roadmap

One of the focuses at the moment is building a framework upon which to actually build games. It starts with the user interface, which is the main focus as seen on our YouTube channel.

However, we can't always make videos and the requirement to explain the process means slowing down progress on development in order to produce high quality videos without constantly programming absent of any commentary. As a result, we have made this page as our blogging platform to demonstrate our progress when we can't make videos.

Once we have established how the user interface should be built, using our own Story Creator project as the means to test and build the library, we will continue to expand and build on other software.

At some point, there will come a time when all the codebases we have made over the years come together to form three separate libraries, each released in their respective languages. These will be Haxe, ODIN and C#.

Why three languages?

• Haxe - Haxe has a powerful macro system and greater flexibility when it comes to targeting platforms. Moreover, it gives the choice to use Kha. This gives an opportunity to target the Web without needing to use WebAssembly.
• C# - C# is still a popular high level programming choice for beginners. It has a far superior Reflection and Type system than either Haxe or ODIN, and has high level language features, including LINQ, null safety (since C# 8), and various other quality of life features not seen in the alternatives.
• ODIN - Considered a modern low-level language, ODIN offers us the option to build software without a garbage collector and access to an array of low-level functionality, including pointers, context-based allocators, arguably a better foreign management system to the alternatives, and more.

To have all these options gives us the ability to choose between whichever language has the toolset we need for the platforms we're targeting and what environment we're building for.

Creating an application that requires us to use a database in the SQL world? Choose C#.

Creating a 2D video game that can be cross-platform and can target both the Web, Desktop and Mobile? Choose Haxe.

Creating a real-time application that requires us to control our memory and maximise performance? Choose ODIN.

All these options are available below (besides the ODIN target for the time being):

Twinspire - Get for Haxe

TwinspireCS - Get for C#

TwinspireOdin - To be released

What we're working on

We are currently building a UI framework in ODIN, as this gives us an opportunity to build for the ODIN language as well as having a compiler that has faster compilation times than either C# (via Visual Studio) or Haxe on the native target. The compilation speed is important as faster testing gets faster results, and the seconds in difference eventually adds up.

Moreover, Raylib is a target best suited in low-level languages for high performance reasons, but that doesn't mean it's slow in C# or Haxe, it just means we have less control.

To get us started, we will build a UI framework combining three of our different concepts, Layouts, Widgets and User-Defined Components, to seamlessly build custom interfaces inline with the existing (eventual) framework.

Once we get to the point of "custom" drawing directly, we begin on the game engine itself. Or what we will call in the foreseeable future, the Real-Time Engine (as it could technically be used for anything). It is within this context that we will draw all our custom graphics, effectively the "game" within which is based on an overarching UI library. This allows us to keep user interactions tightly integrated within a single procedure to minimise errors on mouse and tap events.

There will, of course, be other features, this is all best discussed at the appropriate time.

Our detailed roadmap is as follows:

• Complete a full user interface framework with common layouts and controls.
• Add the features of C#'s codebase on Resource Management into ODIN and Haxe.
• Add the UI features built in ODIN into Haxe and C#.
• Simplify the codebases and bring them all into sync.

We estimate that the above roadmap will take six months to complete, with a new version of Story Creator available once the second point is done (~4 months).