# Comedot is a Godot 4.8 template where gameplay is assembled from components

> InvadingOctopus/comedot is a Godot template and component library for 2D games, where entities and components are ordinary Godot nodes that you snap together in the editor, with 120 plus components, template menus, UI widgets and debug tooling. The author is explicit that it is a personal project with no backwards compatibility guarantee, and that warning belongs at the top of any evaluation.

**InvadingOctopus/comedot** — Godot template and component-based framework for 2D games.

- Repository: https://github.com/InvadingOctopus/comedot
- Website: https://store.godotengine.org/asset/syntaks/comedot/
- Stars: 545 · Forks: 50
- Language: GDScript
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/invadingoctopus-comedot

## A shared library born from a hundred unfinished games

Comedot is presented as an opinionated framework and project template for Godot with the goal of being an all-in-one toolkit for 2D games of any genre, and the list of genres is long, from platformers and shoot-em-ups to RPGs, strategy, puzzles, turn-based and tile-based games. The origin story explains the shape of the thing. The author made it while trying to make a hundred different games and failing to finish one, and whenever something came up that was needed in multiple genres, it went into a shared library. That is the design principle, and it explains both the breadth and the roughness. The intended user is a Godot developer working on 2D who would rather assemble gameplay from existing pieces than write movement, combat, collectibles, interactions and upgrades from scratch each time. It is published under the MIT licence, it is listed in the Godot asset store, and the repository is a complete project rather than a plugin you drop into an existing codebase, which is the single most important thing to understand before evaluating it.

## Entities and components are ordinary Godot nodes

The core idea is that entities and components are just regular Godot nodes, but for gameplay mechanics, which means you can mix the framework with your usual Godot workflow or with any other architecture you prefer. The manual path is spelled out step by step. Create a new entity node, a Node2D, Sprite2D or CharacterBody2D, with the Entity.gd script attached. Add component child nodes to that entity, where a component is any Node or Area2D with a script that extends Component. Modify component parameters in the inspector dock. Then save that entity and components subtree as a standalone scene file, so it is organised separately from the main world scene and copies can be created anywhere. The point of the last step is reuse. A monster, a powerup and the player are the same kind of object with different components attached, and because the composition model is composition over inheritance, you can put a gun component and a node facing component on any object and have it work. The README also shows dynamic gameplay, where components are added and removed in event handlers, so you can swap platformer physics for flight at run time.

## What the template actually contains

The inventory is large enough that the framework is closer to a kit than to a starting point. There are 120 plus components for player movement, combat, collectibles, interactions and upgrades, and 150 plus helper functions and debugging tools, with both lists catalogued in the Notes directory. Templates cover the flow from a logo screen to a main menu to an options screen, plus input remapping and a pause overlay. The UI folder provides stat HUDs and dynamic buttons for special skills and inventory, and there are free-to-use tilesets, fonts and shaders for quick prototyping, along with snippets for VSCode and VSCodium. The debugging side is unusually good for a template, including real-time charts for monitoring variables. Some components also handle the awkward cases that every 2D game hits, such as a collectible that refuses to be picked up while your stat is at maximum, but is collected if the stat drops while you are still standing on it, or climbing behaviour that lets you grab a ladder mid-jump and lets you walk toward a ladder you are not quite aligned with. The author attributes those to special effort rather than to the bare implementation.

## The Comedock plugin and the folder layout

There are three ways in, and the fastest is the plugin. The project ships a custom dock plugin, called the Comedock, which is the intended path for new users, and the alternative is dragging and dropping files from the Entities and Components folders directly into your scene tree. The directory structure is the documentation. Templates holds scenes and entities with preset components as a starting point for basic gameplay, Scripts holds code for nodes that are not entities, UI holds the customisable interface elements, and Assets, Resources, Scenes, Game, AutoLoad, addons, Lab, Tests and Temporary fill out the rest of a working Godot project. Two supporting documents are worth reading before anything else, HowTo.md for basic tasks and common problems, and Conventions.md for the style guide and design rules the project tries to follow. There is also AGENTS.md with instructions for AI assistants, and the README says you can ask AI agents to update an existing project to the latest Comedot branch. The project also states that the components themselves contain no AI-generated code, which is a useful thing to know if you care about where the framework came from.

## The stability warning is the paragraph to read twice

The README carries a warning that changes how you should treat this project. It says the project is still mostly a private personal project, that the API avoids certain naming conventions the author dislikes, that things may break frequently, and in capitals that no backwards compatibility is guaranteed. That is not boilerplate modesty. It means a component you rely on today may change or disappear, and it means the version numbers, which look unusual, encode the Godot release they target and the author's own iteration count rather than a semver promise. The listed releases are 4.8.0.3.666 from 2026-08-20, 4.8.0.3.69 from 2026-08-08 and 4.7.0.100.777 from 2026-07-02, and the badges say Godot v4.8+. The default branch is develop, which is the branch you would fork or clone for a new game, and the repository is not archived with the last push on 2026-10-20. The licence is MIT, so nothing stops you from vendoring the code into your own project and freezing it, and for a shipping game that is arguably the sanest approach anyway.

## Where Comedot is the wrong tool

Three cases come to mind. The first is 3D, since the whole thing is scoped to 2D and the repository even carries a file named 2D Only.gdbuild. The second is a team that needs a supported API. The warning about no backwards compatibility, combined with the personal project framing, means you cannot promise to your team that a component behaves the same in six months, and if you are shipping several games on the same framework that promise matters. The third is a project that already has a well-oiled architecture, because the README explicitly says you can yoink specific code to use in your own scripts, which is an invitation to ignore most of the template. There is a real cost to importing the whole thing into a codebase with its own conventions, since the framework is opinionated by design and its settings, AutoLoad entries, project settings resource and testing directories all assume a particular project shape. The framework also ships with the assets it needs, and a licence review of any third party tilesets or fonts you keep in a shipped game is your responsibility, not the framework's.

## Adopting the whole template versus borrowing a single script

There are two adoption paths and the README points at both. The first is to clone the repository, since this is a Godot template you should make a local copy of the entire project for each of your games, and then build inside its conventions. You get the components, the menus, the UI, the debug charts and the editor plugin, and you accept the opinions, the breaking changes and the requirement that you keep pulling updates. The second is to take individual pieces, for example the helper file at Scripts/Tools/Tools.gd, and drop them into a project you already have, keeping your own architecture and taking on the maintenance of that code yourself. The difference in approach is about who owns the framework. With the full template, the framework is a dependency you track and fork, and you inherit a large codebase whose style you did not choose but which saves you from writing dozens of mechanics. With the single script, you own everything you take and you inherit nothing else, which is cheaper to start and cheaper to maintain if you only needed a handful of pieces. A game jam and a commercial title with a long life will usually want different answers, and the README does not try to hide that choice.

## Conclusion

Comedot fits a solo developer or small team making 2D games who wants a large set of ready-made gameplay components, menu scenes and debug tooling instead of writing each mechanic from scratch, and who is prepared to own the framework and change it. It does not fit a 3D project, and it does not fit a team that needs a stable, versioned API across several games. Before starting, read the warning in the README and the HowTo.md and Conventions.md files, and note that the last push was on 2026-10-20 with the newest listed release 4.8.0.3.666 from 2026-08-20, so you are tracking a moving target on the develop branch.

## FAQ

### What is Comedot and what engine does it target?

Comedot is a Godot template and component-based framework for 2D games, written in GDScript and published under the MIT licence. The badges state Godot v4.8+, and the release versions follow the 4.8.0.x pattern.

### How do I add a component to an entity in Comedot?

You create an entity node such as a Node2D, Sprite2D or CharacterBody2D with the Entity.gd script, add component child nodes whose scripts extend Component, then adjust the parameters in the inspector. You can also drag files from the Entities and Components folders into your scene tree, or use the included Comedock plugin.

### Is the Comedot API stable between versions?

No. The README warns that the project is still mostly a private personal project, that things may break frequently, and that no backwards compatibility is guaranteed. The repository is not archived and the last push was on 2026-10-20.

### Can I use Comedot with an existing Godot project instead of the template?

Yes. The README says that if you do not need the entire template you can take specific code, such as the helper file Scripts/Tools/Tools.gd, and use it in your own scripts, keeping your own architecture.

## Sources

- [InvadingOctopus/comedot on GitHub](https://github.com/InvadingOctopus/comedot)
- [License: MIT](https://github.com/InvadingOctopus/comedot/blob/develop/LICENSE)
- [Project website](https://store.godotengine.org/asset/syntaks/comedot/)
- [README](https://github.com/InvadingOctopus/comedot/blob/develop/README.md)
- [Releases](https://github.com/InvadingOctopus/comedot/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/invadingoctopus-comedot