The north star. Every decision in this repo should trace back to something here. If a feature doesn't serve this vision, it doesn't go in.
Most engines optimize for fidelity — making a thing look like a real thing. Floptle optimizes for the reaction:
"I've literally never seen anything that looks like this. It looks like it's from another dimension."
Surreal. Otherworldly. Trippy. Complex. And, a few layers down, quietly nostalgic and dreamlike. We are willing to break conventional rendering norms — and the "laws" of light and geometry themselves — to get there. Realism is not a goal; novelty of perception is.
This is a creative instrument first and a technical artifact second. But to be a great instrument it must also be fast, lightweight, and a pleasure to use.
A solo (or tiny-team) maker who:
- builds surreal, dreamlike adventure games and flashy, fast combat games,
- models in Blender and wants those models in-game with no fuss,
- has VFX instincts and is tired of clunky particle tools,
- wants to write shaders by graph and by text (with AI help),
- self-hosts, and may one day want networked games on their own infra,
- and above all wants to make freely, without other people's restrictions.
The first such maker is Ty / Fopull LLC. The engine should feel tailor-made.
We deliberately do not chase:
- Photorealism, film-grade PBR, or AAA-scale rendering features.
- Unreal-tier animation (complex IK rigs, motion matching, mocap pipelines).
- A giant property-soup UI for every subsystem.
- Being everything for everyone. Opinionated > configurable-to-death.
When in doubt: the simplest thing that gives the maker real creative control.
A custom render graph whose default toolbox is signed-distance fields and raymarching, not just triangle rasterization. Fractals are math, so we render them as math — letting you fly inside a fractal and watch its geometry and patterns morph into each other in real time. Layered with screen-space passes that intentionally violate normal lighting (impossible color transport, melting space, feedback trails) to produce the "from another dimension" look.
One shader is one source of truth, the Floptle shader IR. Edit it as a node
graph in the editor; press a button and the same shader opens as readable text
(.flsl) in VSCode for AI-assisted authoring; switch back freely. The IR
transpiles to WGSL. Owning the shader representation is our biggest lever for
visuals nobody else can make.
Name an effect → set its lifetime → choose looping vs. one-shot → a timeline
appears. Drop particle groups on it (e.g. "Crescents", "Smoke"), each with
its own behavior. Every property is a constant or a curve over lifetime
(hover a corner, a graph icon appears, draw the curve). Emission is either an
auto rate ("once every 0.2s" → auto Emit events on the timeline) or
hand-placed Emit events you scatter wherever you want. This is the whole flow,
in-engine, designed by someone who's actually done VFX work.
- Scene view you build in: right-click → Create → Shape → draw a base on the ground, pull it up to set height; procedurally generated Cube/Sphere/ Cylinder/Capsule/Wedge/Stairs (stairs has a "step count" property), all editable after creation, collidable toggle, material + texture per shape.
- Textures that just tile: drag a texture onto a surface, say "repeat 3×, flip on alternate" — no shader required.
- Dead-simple UI: arrange elements, anchor them, script what they do.
- Built-in dialogue: typewriter text with per-character voice SFX, skip-to- full, advance-on-interact, woven into cutscenes — themeable, good defaults.
- Cameras: first-person, third-person, and clean gameplay↔cutscene blends.
- Automatic object pooling: take/return from a pool; no manual setup.
- Input: bind any key/mouse/gamepad input(s) to named actions; script them.
- Nodes + components/scripts: attach a script, click it, it opens in VSCode with the project as the workspace root and that script focused.
Nothing in Floptle is forced to be a static box. Any object — a fractal or a shape you built — can be told how it behaves as physical matter: its vertices can morph and shift in real time while staying cleanly collidable; two pieces of geometry can blend together like soup, mix, or reject each other; objects can be given soft-body behavior, made to stick and physically stretch when pulled, and (later) tear into stringy strands and split apart.
The trick that makes this both possible and fast: all geometry shares one
implicit-field substrate (signed distance functions), so combining shapes is
just math (smooth-min/-max with a blend radius), and the same field the renderer
draws is the field physics collides against — a deformed object is automatically
renderable and collidable, no desync. Complexity is opt-in via tiers (Rigid →
Morph → Field-blend → Soft-body → Viscoelastic): you only pay for the behavior you
reach for. This is the engine's most distinctive underlying system. See
subsystems/deformable-matter.md and ADR-0013.
And because matter has density, it has mass, and mass emits gravity —
so gravity in Floptle is a field g(p), not a global constant. You can run
around on a fractal and up its swirling walls, kept grounded by the field the
surface emits (not floaty anti-gravity); orbit and then land and walk on
procedural fractal planets; or fly a ship between them. Density also decides
whether matter crushes under pressure (soft clay) or resists (hard metal).
The engine understands space, matter, gravity, and density as one idea. See
subsystems/gravity-and-density.md and ADR-0014.
The deepest version of all of the above: a Floptle game is a small simulated
universe, and the things you'd normally hardcode — how light travels, how time
flows, how gravity points — are rules you declare, not exceptions you script.
Light becomes a fourth field on the same substrate: bend rays, and the same rule
that makes mass pull can make photons fall (light.md,
ADR-0016). Time becomes a rate field r(p): slow, freeze, or dilate a region while
the rest of the world keeps moving (time.md, ADR-0017). A
world's laws live in one place — a Lawset bound to a region (a Realm),
resolved by the SDF inside-test, inheritable and hot-reloadable; a Floptle world is
literally a lawset.ron you can diff and gift as "here are the laws — bend them"
(world-rules.md, ADR-0018). The honest frontier is
making those rules compose by design rather than by coincidence — a
field-interaction graph where one law feeds another, so worlds surprise you in ways
you didn't script (ADR-0019). This is why a player believes the wall-run: it
isn't a trick, it's what must happen under this world's rules.
- Ships for Linux, Windows, macOS from one codebase.
- Lightweight & fast is a feature, not an afterthought — measured, not hoped.
- Large worlds by default: the world moves around the player (floating-origin /
camera-relative space), so you can simulate a whole galaxy and travel
absurdly far with no precision jitter — automatic, zero developer work. See
subsystems/large-world-space.mdand ADR-0015. - Networking is explicitly future (dedicated server build + clients on the maker's own infra), but the architecture must not preclude it.
The editor is dark-themed, somewhat high-contrast, retro / pixel-art inspired — yet organized, readable, and clear. High user customizability and control. The tool should feel like it belongs to the same universe as the games it makes.
Floptle becomes a (free, open-source, donation-supported) Fopull LLC product when:
- A maker can build a small surreal game and a small combat game end-to-end using only the features above.
- It exports running builds for all three platforms.
- All third-party placeholder test assets are replaced with original Fopull art (see ADR-0010).
- The headline features (renderer, shader IR, VFX timeline, scene-building, UI, dialogue, pooling) feel better to use than the incumbents — that's the whole point.
See ARCHITECTURE.md for how the pieces fit, and the
release notes for what has actually landed.