TL;DR
Cleoselene is a multiplayer-first game engine that runs game logic and rendering on the server using Lua scripts, streaming drawing primitives to clients. Performance-critical subsystems like physics and pathfinding run in native Rust and networking uses WebRTC; the engine is free to self-host for personal or commercial use.
What happened
A new engine, Cleoselene, presents a server-rendered approach to multiplayer game development where developers write game logic in Lua and run all simulation and rendering on the server. Game scripts implement a small set of callbacks (init, update, draw, on_connect, on_disconnect, on_input) that the server invokes: update advances the physics world and processes collisions, while draw generates a per-client frame by issuing drawing primitives. The runtime exposes a fixed 800×600 virtual coordinate system and APIs for basic graphics, text, and sound. A spatial hash grid is provided for entity queries; objects can be added as circles or segments and managed through the DB API. Physics and pathfinding (A*) are executed in native Rust for performance, and the server streams drawing primitives to clients over WebRTC. The model keeps game state server-side, which the project highlights as a mitigation against typical client-side cheats. The engine is offered free for self-hosting without per-player fees.
Why it matters
- Simplifies multiplayer development by removing client-side state sync and per-client authoritative logic.
- Server-side rendering and state reduce attack surface for common client-side cheats and reverse-engineering.
- Streaming lightweight primitives aims to be more bandwidth-efficient than sending pixels or complex object state.
- Native Rust subsystems may improve simulation performance and deterministic behavior at scale.
- No vendor lock-in: the engine version described is free to run on your own infrastructure.
Key facts
- Developers write Lua game scripts that implement init, update, draw, on_connect, on_disconnect, and on_input callbacks.
- The engine uses a fixed virtual coordinate space of 800×600; output is scaled to client screens automatically.
- Graphics API includes commands like api.clear_screen, api.set_color, api.fill_rect, api.draw_line, and api.draw_text.
- Sound API supports api.load_sound, api.play_sound, api.stop_sound, and api.set_volume.
- Spatial DB is a Spatial Hash Grid created via api.new_spatial_db(cell_size) with object methods (add_circle, add_segment, remove, update, get_position) and query methods (query_range, query_rect, cast_ray).
- Physics world created with api.new_physics_world(db) provides phys:step, phys:get_collision_events, body management, velocity control, and gravity settings.
- Navigation uses a built-in graph (api.new_graph) with add_node, add_edge, and nav:find_path (A*).
- Performance-critical logic (physics, pathfinding) runs in native Rust; communication uses WebRTC for low-latency streaming of drawing primitives.
- The client receives streamed drawing primitives and, according to the project, has no direct knowledge of server game state, which the project frames as preventing client-side cheating.
- The engine distribution is free for personal or commercial use on self-hosted infrastructure with no per-player fees.
What to watch next
- not confirmed in the source
- not confirmed in the source
- not confirmed in the source
Quick glossary
- Server-rendered: A model where the server performs rendering and produces frames or drawing commands that clients display, rather than having clients render using local game state.
- Spatial hash grid: A broadphase spatial indexing structure that divides space into cells to accelerate queries for nearby entities.
- WebRTC: A protocol and set of APIs that enable low-latency, peer-to-peer or client-server real-time communication in browsers and other clients.
- A* (A-star) pathfinding: A heuristic search algorithm commonly used to find the shortest path between nodes on a graph.
- Drawing primitives: Basic graphic commands (lines, rectangles, text) streamed to a client to compose a visual frame instead of sending rendered pixels.
Reader FAQ
Do I need client-side game code?
No. The engine is designed so the server runs simulation and issues drawing primitives for each client; client-side game logic is not required according to the source.
What language do I use for game scripting?
Lua is used for game scripts in this engine.
Can I host the engine commercially?
The source states this version is free for personal or commercial use on your own infrastructure.
Does server-rendering eliminate all cheating?
The project states clients have no knowledge of game state and frames this as preventing common client-side cheats; further details are not provided.
Which client platforms are supported?
not confirmed in the source
Cleoselene Manual A Multiplayer-First Server-Rendered Game Engine with Lua Scripting. Game Structure A minimal game script (main.lua) must implement these callbacks: — Called once when the server starts function init()…
Sources
- Server-rendered multiplayer games with Lua (no client code)
- [SOLVED] Create a server-based game with Defold
- iErcann/NotBlox: 3D Three.JS, Node.js Multiplayer Game
Related posts
- Seed of Life: Web interface exposes adjustable visual controls and resets
- Aliro standard set to launch in 2026, bringing NFC and UWB to smart locks
- LG’s CLOiD home robot will fold laundry and make breakfast at CES