Floptle is a free, open-source game engine. Host a game with one line of Lua and your friends join with a six-character code, through our relay, from anywhere. Nobody opens a port and you rent no server. Around that sits a whole engine in one native binary for Windows, macOS and Linux: worlds you can carve, an editor, Lua, shaders, physics and audio, and a command line an AI assistant can drive.
Multiplayer is one line, free for 100 players, and nobody port-forwards.
net.host{ relay = "cloud" }, then show net.lobbyCode().net.join("cloud://" .. code).Pre-1.0 and moving fast · MIT OR Apache-2.0 · no account required
Retro mode renders the whole frame at a low internal resolution, post-processing and all, then upscales it. You get a PS1/N64 look running on top of modern lighting. It is the default aesthetic I designed the engine around, so lead with it when you show the thing off.
Not tech demos. Finished games on real deadlines, each one with a page of its own.
A short first-person PSX-style horror game. You and several strangers wake up inside a mysterious mansion, but not all of you are human. Written from nothing in four days and shipped on Windows, macOS and Linux the same weekend, free on itch.io.
74 pages, published with the engine release itself, so what you read describes the build you can actually install.
Install it, get something on screen, walk around in it.
6 pagesWhole small games, step by step. The same steps are in the editor's Learn tab, where each one ticks itself off as your project comes to match it.
15 pagesLua, and every call the engine answers.
10 pagesThe tools that come with the engine, rather than around it.
3 pagesModular expansions anybody can write and share: editor tools, scripts, art. Install one, or publish your own.
4 pagesThe UI layer, from the tab that draws it to the code that binds it.
5 pagesGetting it to players, and to more of them.
28 pagesEach subsystem, in its own words. Read these to find out what the engine can actually do.
The editor has a Learn tab with follow-along projects, a 3D platformer, a top-down RPG, Flappy, and each step ticks itself off as your project comes to match it. You are never left wondering whether you did a step right, and the docs one tab over always match the version you are running. It is the way I would want to learn an engine from zero.
Ask whether a project loads, play it headless and get every error with its file and
line, render a frame to a PNG, read a scene tree, or change a project through the editor's own
scripting API, all without opening the editor. Every command reports whether it needs a display
and whether it writes to your project, and floptle help --json describes the whole
surface, so an assistant reads the interface once instead of guessing at it.
Most engines hand you a heightmap. Floptle stores terrain as a real 3D signed-distance field, so caves, overhangs, tunnels, and floating islands all work, and you can edit any of it while the game is running.
Players can dig, sculpt, and reshape the world at runtime, not just me in the editor. The edits get written into the save file, so a tunnel you carve is still there after a reload.
The demo builds spherical worlds you can walk on, tunnel through, and hollow out. You can drop several terrain volumes into one scene and they blend together on the GPU with a smooth-min.
Save checkpoints stream terrain edits to disk in the background so the framerate holds. A floating-origin world keeps planet-scale scenes from getting jittery.
Add the 🌐 Networked component to a node, call net.host{ maxPlayers = 4 }, and you have a real client talking to a real server. No plugin, no service to sign up for, no separate networking library to learn. You pick a replication mode per node and a project that does not use a mode never pays for it.
Server authority is the default: cheat-proof and it needs nothing from your scripts. Predicted keeps the player's own avatar snappy. Rollback re-simulates every peer every tick for fighting games, GGPO style, with mandatory desync checksums. Mixing them in one scene is normal.
Press Play, then host and join a local client inside one process, with sliders for latency and packet loss. Turn it up to 200 ms and 10% loss before you ship, and find the bug that only appears on a bad hotel wifi without leaving your chair.
A host gets a five-letter lobby code and a joiner types it in, through a tiny open-source relay you can run on any box with cargo run -p floptle-relay, or connect direct over LAN. Inputs and the seed are the match, so a full replay is kilobytes and plays back by re-simulating.
The rollback mode is being hardened against a real fighting game built on the engine, and the whole model is written up in the docs, from the five-minute server-authoritative version to the strict rollback contract. Read "Making a multiplayer game".
Everything below is one game project I scripted in Lua against the engine's public APIs. None of it is baked into the engine. Generate a system, fly out to it, land, and dig.
Patched-conic trajectories, sphere-of-influence transfers, clickable maneuver nodes on the map, SAS hold modes, and time warp. It all reads off the ship HUD as you climb out of the gravity well.
Transfer to a moon, land, get out, and walk. Gravity volumes hold you to the surface of a small body instead of a flat plane. The loading screen builds your starting planet first and drops you somewhere safe on it.
Carve into the world with the ship tools and drop below the surface. The shadows and ambient occlusion down there come straight off the distance field. Quicksave, come back later, and the tunnels are still where you left them.
Grab the full solar-system project, the same one in the shots above, and open it in the Floptle Hub. It is a real Floptle project scripted in Lua, so you can crack it open, read the source and remix it. The project has its own repository, Fopull-LLC/Solar, where the Lua is readable and issues go.
Solar.
New here? You'll want the Floptle Hub first — it installs the engine and runs projects like this one. The demo is the project; the Hub is what opens it.
Volumetric signed-distance terrain with runtime editing, GPU smooth-min blending between volumes, and planet-scale scenes.
Hybrid raymarch and raster, so SDF terrain and meshes share a scene. SDF-derived soft shadows and AO, plus bloom and vignette, rendered low-res and upscaled for the PS1/N64 look.
A text shader format with a visual node editor. Live per-node previews, drag a value to change it, no recompile. Nodes can define raymarched SDF geometry that still takes shadows and AO.
Lifecycle hooks, collision and trigger events, prefab spawn and destroy, raycasts, layers and tags, and Inspector-editable script parameters that read back both ways. In-engine API docs, plus bundled EmmyLua annotations for autocomplete in VSCode.
Dynamic, kinematic, and static bodies, trigger sensors, SDF and mesh colliders, a collision-layer matrix, and raycasting. Gravity volumes let you walk around a small planet, and kinematic platforms carry the player.
Tracks, clips, bursts, automation lanes, curve editing, random ranges, and mesh particles, with a deterministic scrub preview. It works like an audio or video timeline.
Spatial 3D voices and a project mixer with 11 effect types and an EQ curve editor, driven from a Lua audio API. Skeletal animation clips import from glTF and play from Lua.
The launcher and version manager. It installs engine versions, creates projects pinned to a version, does one-click upgrades, shows a banner on new releases, and can sign in with your fopull.com account if you want.
That is the shape of the engine, not a changelog. For what landed most recently, read the release notes — they are the engine's own.
A component Inspector modeled on Unity, prefabs you drag in and out of the asset browser, multi-select hierarchy, undo, and play-in-editor with the inspector staying live. There are dedicated tools for shaders and effects too.
Particle timeline. Tracks and clips with size and color over-life automation lanes and curve editing. This burst is authored on a timeline you can scrub.
Lua scripting. Write gameplay in Lua right in the editor, or open it in VSCode with the bundled autocomplete. This is the controller that walks the astronaut around a planet.
Making backrooms level in the editor
Story mode cutscenes made in engine with dialogue system
Dissolve Shader Shader graph
Forgery S S3 In Engine In-Engine scripting API docs
Forgery S S1 In Engine Horror game main menu
Floptle is dual-licensed MIT OR Apache-2.0, and the README has a permissive-forever pledge. No royalties, no fees, and you do not need an account to use the engine. Read it, fork it, file an issue, or send a pull request. Watch the Releases page if you want to know when a new version lands.
▹ What is being worked on right now comes straight from the engine.
The Hub installs the engine and keeps it updated. Grab it for your platform, then install an engine version and create a project. Everything runs locally on your machine.
Heads up, the binaries are not signed yet. On macOS, right-click the app and pick Open the first time. On Windows, if SmartScreen shows up, pick More info then Run anyway. Signing is on my list. For a young open-source project this is normal.
Floptle is a free, open-source game engine I build for making stylized 3D worlds. It stores terrain as a volumetric signed-distance field, so you can dig into and reshape whole planets while the game runs. The download includes the editor, Lua scripting, a node-graph shader editor, a particle timeline, spatial audio, and physics, all as one native binary for Windows, macOS, and Linux. The Floptle Hub installs it and keeps it updated.
The terrain is a real 3D signed-distance field rather than a heightmap, which gets you caves, overhangs, tunnels, and floating islands, and lets you edit all of it at runtime. Players can dig and sculpt the world live, and those edits persist in the save file. Whole planets are terrain, so the demo builds spherical worlds you can walk on, tunnel through, and hollow out. Put that together with the retro-mode renderer and that combination is the main reason to pick it.
Desktop. Windows on x86_64, macOS on both Apple Silicon and Intel, and Linux on x86_64, each as a small native binary. There is no console or mobile support.
Yes. Floptle is free and open source, dual-licensed MIT OR Apache-2.0, and the README has a permissive-forever pledge. No royalties, no fees, and you do not need an account to use the engine.
It is pre-1.0, currently v0.117.0, and I am moving fast on it. It is young and it changes often, so treat it that way. If you like being early and reading the source, it is a good fit.
Yes, and learning is a specific design goal. The editor has a Learn tab with follow-along tutorial projects, a 3D platformer, a top-down RPG, Flappy, and a squad pathfinding project, where each step verifies itself against your actual project and ticks off when it is really done. The complete documentation ships inside the editor too, so what you read always matches the version you are running. Scripts are written in Lua, one of the friendliest first languages.
Download the Floptle Hub, create a project, and open the Learn tab in the editor. Start with the first-steps tutorial, which has something moving on screen in about fifteen minutes, then build Flappy for a first finished game. The same tutorials are readable on this site under Learn, published from the engine release itself.
The Hub is the launcher and version manager. It installs engine versions, creates and manages projects (each one pinned to an engine version), handles one-click upgrades, and shows a banner when a new release ships. You can also sign in with a fopull.com account, which is optional.
Yes, it is built into the engine rather than bolted on. You add one Networked component to a node and pick a replication mode: server authority (the cheat-proof default), predicted (for the player's own avatar), or rollback (every peer re-simulates every tick, GGPO style, for fighting games). Players connect with a five-letter lobby code through a small open-source relay you can self-host, or directly over LAN. The editor can host and join a local client in one process with latency and packet-loss sliders, so you can rehearse a 200 ms connection at your desk. The rollback mode is being hardened against a real fighting game built on the engine.
Not yet, the binaries are currently unsigned. On macOS, right-click the app and choose Open the first time. On Windows, if SmartScreen appears, choose More info then Run anyway. Code signing is on my list.
It is a game project I built in Floptle, scripted in Lua against the engine's public APIs, so none of it is hardcoded into the engine. It generates procedural solar systems from a seed and runs real orbital mechanics: patched-conic trajectories, sphere-of-influence transfers, clickable maneuver nodes, SAS, and time warp. You can fly from a planet's surface up to orbit, transfer to a moon, land, walk around under that body's gravity, and dig into the planet, and the edits are still there after a quicksave. It is there to show what one project on the engine looks like, since the engine itself is general purpose.
I also build Storage Sifter, an open-source Linux disk-usage tool, Foduel, a real-time online trading card game, and Foverse, my blogging and community platform that hosts the free Connect Fo. If a Rust game engine is what brought you here, the rest is worth a look.
Long answers to the questions that come up while you are building, with the real commands and the parts that go wrong.
Why your friend cannot connect to your game, what a relay actually does about it, and the one line that hosts a Floptle game for 100 players free.
An AI coding agent has a terminal and your files. A game engine keeps everything else behind a window. Here is how we closed that gap in Floptle.
The current release and what is coming, written when the release went out and read straight off the engine. Everything older is on the release history.
. Whole planets with rivers, mountain ranges and weather that stream in without stalling, craft with hinges and wheels, water to float on, volumetric fog with light shafts, and meshes, pictures and compute shaders a script makes itself. Everything from the 0.117 betas.
Whole planets you can walk, dig, fly round and build on, with rivers, mountain ranges and weather, that stay smooth while they stream in around you. Craft with hinges, pistons and wheels. Water to float on. Volumetric fog with light shafts. Meshes, textures, pictures and now compute shaders a script makes itself. This is everything from the v0.117.0 betas, rc1 to rc38.
terrain.stats() and terrain.setBudget() say what
terrain holds and keep it to a budget.image.new, many times faster than painting pixels from Lua.gpu.buffer, gpu.texture and compute.run run
programs on the GPU that draw nothing, for procedural textures, particle
swarms and simulations, on every platform Floptle ships to. See
Compute shaders.assets.warm
prepares a level before its first frame, and spawns a game can spread over
frames keep busy moments smooth.findScript(kind, { quiet = true }) looks without a warning.floptle check compiles every script, and fails on a syntax error at its
file and line.Projects upgrade themselves to keep their look. Nothing to change by hand.
Flying a ship you built. Compound vessels assemble, dock and come apart already. What's missing is a flight controller that handles a machine whose shape you invented — centre-of-mass and centre-of-thrust readouts while you build, and atmosphere that pushes back on the way up and the way down.
The arcade fighter. Fofighter is a real game being built on the engine, and it's where the netcode gets its hardest test. Nearly every rollback fix in the v0.10.x releases came from it — which is the point of building a game in your own engine.