-
Notifications
You must be signed in to change notification settings - Fork 5
Home
Tilky Engine is a sector-based 3D game engine and editor for building retro-style 3D games.
It is inspired by classic engines such as Doom and Build Engine, but it renders the world with modern hardware-accelerated 3D graphics. Levels are built from sectors, walls, floors, ceilings, sprites, decals, and entities instead of large freeform mesh scenes.
Tilky Engine is designed to provide a full workflow for making a game:
- Create a project
- Build levels visually
- Place entities
- Add textures, sprites, decals, audio, and scripts
- Test the game inside the editor
- Export the project as a standalone build
The engine currently uses OpenGL for rendering. Vulkan support is planned for the future.
Tilky Engine is not a general-purpose engine like Unity, Unreal, or Godot.
Its main focus is sector-based 3D level design. A map is built from connected rooms and spaces called sectors. Each sector can have its own floor height, ceiling height, textures, and connected walls.
This makes the engine especially suited for:
- Retro shooters
- Doom-like games
- Build Engine-style games
- Sprite-heavy 3D games
- Fast hand-made level design
- Compact indoor maps
- Stylized low-poly or retro 3D projects
Tilky Engine supports true 3D perspective, textured walls, floors, ceilings, billboards, sprites, decals, entities, collision, scripting, audio, and standalone exporting.
Tilky Engine levels are built using sectors.
A sector represents a playable space in the map. Sectors are connected together through walls and portals, allowing the player to move between rooms, corridors, platforms, and height changes.
A level can contain:
-
Sectors Room-like spaces with their own floor and ceiling heights.
-
Walls The boundaries of sectors. Walls can be textured and can also connect sectors together.
-
Floors and ceilings Each sector has its own floor and ceiling surface.
-
Entities Objects placed in the world, such as players, enemies, props, triggers, lights, or scripted objects.
This approach makes level creation more structured than a full mesh editor, while still allowing verticality, different room heights, stairs, platforms, and classic retro 3D layouts.
Tilky Engine is built around quickly creating playable spaces. The sector workflow is intended to make it easy to block out rooms, connect areas, assign textures, and test the result without needing an external 3D modelling program.
The engine is designed for games that want the feel of classic 90s 3D engines while still using a modern rendering pipeline.
It is a good fit for projects using:
- Pixel-art textures
- Sprite-based enemies or objects
- Low-poly props
- Simple geometric environments
- Stylized lighting and atmosphere
- Doom-like or Build-like layouts
Tilky Engine includes both an editor and a runtime.
The editor is used to build the game. The runtime is used to play and test the game. The goal is to make the workflow direct: build something, press play, test it, then return to editing.
Tilky Engine aims to be easy to use without removing control from the developer.
The engine is intended to expose the important tools directly: map editing, entities, components, scripting, audio, testing, debugging, and exporting.
Projects can be exported into standalone builds, allowing games made with Tilky Engine to run outside the editor.
The editor allows you to create and edit maps visually.
Current editor features include:
- Wall editing
- Sector editing
- Entity placement
- Texture assignment
- Component editing
- UI editing
- Runtime testing
- Save & Play workflow
- Selection tools
- Debug visualization
Tilky Engine renders sector maps in true 3D.
The renderer supports:
- Textured walls
- Floors and ceilings
- Sprites
- Decals
- Entity rendering
- Debug rendering
- Depth-tested 3D scenes
The engine currently uses OpenGL as its rendering backend.
Gameplay objects are represented as entities.
Entities can be given different components depending on what they need to do. For example, an entity may have a visual sprite, a collider, a rigidbody, an audio source, or a script.
This is how objects in the world are configured without hardcoding every object type into the engine.
Common entity features include:
- Transform
- Sprite
- Decal
- Camera
- Collider
- Rigidbody
- Player controller
- Audio source
- Custom Script
Tilky Engine supports Lua scripting for custom gameplay behavior.
Scripts can be attached to entities and used to define how objects behave during gameplay.
Scripting can be used for:
- Player behavior
- Enemy behavior
- Interactive objects
- Triggers
- Doors
- Pickups
- Game logic
- Runtime events
Tilky Engine includes a custom lightweight physics and collision system designed around sector-based worlds.
It supports:
- Entity collision
- Rigidbody movement
- Gravity
- Floor and ceiling constraints
- Collider debugging
- Sector-aware movement
- Basic trigger and interaction logic
Tilky Engine includes 3D audio support.
Audio sources can be placed in the world, and the listener follows the active camera or player. This allows sounds to behave spatially inside the level.
Tilky Engine has localizations done by the community to allow for as many users as possible to enjoy it!
Tilky Engine projects can be exported into standalone builds.
The exporter packages the game runtime and project files so the game can be distributed and played outside the editor.
Tilky Engine includes built-in support for Tracy profiling.
When using a profiling-enabled build, the user can open the Tracy Profiler and immediately inspect engine performance without adding custom instrumentation or changing project settings.
Tracy can be used to inspect:
- Frame time
- Rendering cost
- Physics cost
- Collision cost
- Scripting cost
- Runtime update cost
- System bottlenecks
This makes it easier to understand where performance issues are coming from while working on a project.
For example, if a level starts running slowly, the user can open Tracy and check whether the problem is caused by rendering, scripts, physics, collision, or another runtime system.
A typical Tilky Engine workflow looks like this:
- Create or open a project
- Build a level using sectors and walls
- Assign textures to walls, floors, and ceilings
- Place entities in the world
- Add components, scripts, audio, and gameplay logic
- Use Save & Play to test the game
- Debug and profile the project
- Export the finished project as a standalone build
Tilky Engine is mainly intended for developers who want to make retro-style 3D games with a focused toolset.
It is a good fit if you want to build:
- Retro FPS games
- Doom-like games
- Dungeon crawlers
- Sprite-based 3D games
- Experimental sector-based games
- Small standalone 3D projects
- Games with custom engine control
It may not be the best fit if you need:
- Large open-world terrain
- Advanced mesh-based scene editing
- Full physically based rendering
- Complex skeletal animation pipelines
- AAA-style asset workflows
- A general-purpose engine replacement for Unity or Unreal
This wiki should eventually include:
- Getting Started
- Creating a Project
- Editor Overview
- Building Your First Level
- Sectors and Walls
- Textures and Materials
- Entities and Components
- Scripting
- Physics and Collision
- Audio
- UI Editing
- Localization
- Exporting a Game
- Troubleshooting
- Roadmap
Tilky Engine is distributed under the Apache License 2.0.
See the repository LICENSE file for details.