The idea of creating our own game engine came from working on projects that required deeper control over how the underlying systems functioned, particularly when supporting specialized hardware or niche platforms that often required direct access to and modification of the engine source code.

We also encountered challenges with older projects built on commercial engines, where major changes between engine versions made it difficult to maintain compatibility. In many cases, projects could no longer be opened or exported without extensive upgrades, often introducing new issues or breaking existing functionality. Developing our own engine gives us greater control, long-term stability, and the ability to support our projects without being dependent on external development roadmaps.

There are also many cases where we only need a lightweight executable for a small application or non-game project. Commercial engines often come with a large collection of built-in features and assets that may not be relevant to the project, yet they are included as part of the package. This can significantly increase the final file size and introduce unnecessary overhead, resulting in higher resource usage and reduced performance. By having our own engine, we can include only the components we need, keeping applications lean, efficient, and easier to deploy.

First, while Godot is open source, it is designed primarily as a complete game engine rather than a modular SDK. It does not provide a lightweight solution for non-game applications or projects that require only a subset of its features. For example, it is not intended for scenarios where you need to embed a custom 3D rendering window into another application, such as a CNC control panel, a scientific calculator simulator, an AI chatbot with integrated 3D visualization, or other specialized software.

As for Unreal Engine, it is not truly open source but rather source-available. This means its usage is still governed by Epic Games' licensing terms, which may impose restrictions on what can and cannot be done with the engine. In addition, the large and complex codebase can introduce compatibility challenges with other libraries and may not align well with certain project requirements. Unreal Engine is also resource-intensive, making it less suitable for smaller-scale applications. For these reasons, we generally recommend a more lightweight and flexible solution that is both genuinely open and available as an SDK rather than a monolithic game engine.

While our focus is not exclusively on game development, and we are not attempting to compete directly with Unity, Godot, or other established game engines, the editor serves an important purpose in validating and improving the SDK.

By building both an editor and actual games with the SDK, we gain firsthand experience with its strengths and limitations. This practical usage helps us identify missing features, usability issues, and areas for improvement that may not be apparent through design and planning alone. In other words, the editor acts as a real-world testbed that ensures the SDK evolves based on actual development needs rather than assumptions.

Our objective is to create a robust, flexible SDK that can support games as well as other types of applications, and developing our own tools and projects is the most effective way to achieve that goal.

Although we ultimately plan to support a wide range of platforms, version 1.0 will focus primarily on desktop environments, including Windows, macOS, and Linux. We may also explore support for FreeBSD, although this is not guaranteed at this stage.

Our goal is to ensure that the editor can be used to create and publish a complete mini-game from start to finish with minimal friction. Developers should be able to export their projects to the target platform without requiring additional manual modifications. At the same time, we want to ensure that the SDK provides all the essential features needed for game development while remaining simple, lightweight, and easy to work with.

For rendering, we will initially focus on OpenGL and possibly DirectX 11. This will allow us to validate the engine's renderer abstraction layer and ensure that the SDK can support multiple rendering backends without unnecessary complexity.

For the first release, our priority is usability, stability, and a smooth development experience. More advanced and innovative features can be introduced in future versions once the core foundation has been proven and refined.

The SDK is released under the MIT license, which allows it to be safely embedded into any project or third-party application with minimal restrictions. It is broadly compatible with other licenses and avoids conflicts, giving developers the flexibility to use it however they prefer, whether as a static or dynamic library.

The editor, on the other hand, is licensed under GPL v3. Since it is a standalone application rather than a library intended for embedding, there are no licensing compatibility concerns in that context. Choosing GPL v3 also encourages collaboration and contributions back to the editor, making it a better fit for fostering an open and community-driven development model.