Generate
Roll a whole cave system from intent — chambers, connections, dressing — then refine it with the Sculpt verbs. It writes the same recipe; Undo brings back whatever was there before.
Tip: the Cutaway slider up top shows the whole layout like a map. Every roll is different — click again until one speaks to you, then sculpt it.
Sculpt
Shape the space. Every change rewrites the environment's recipe and the engine regenerates the cave — what you see is exactly what the game will generate.
Shape
Structure verbs
Blobs and carves are entries in the recipe — rerolling or resizing the cave keeps them. Click one above to move and resize it.
Tunnels
Sketch a gallery
Draw a stroke — it becomes a flat-floored gallery melted into the cave (top-down view; the cave center is the middle of the pad).
Materials
What the cave is made of. Choices apply to the whole cave today; painting regions comes later.
Editing the live cave needs the engine — the Forge is the cave-authoring surface. Connect the engine and the wall / ore / floor / growth controls appear here.
Texture library
Every PBR material the engine ships (albedo + normal + roughness). Click one to inspect it on the cube — drag the cube to turn it.
Paint regions — floor vs. ceiling vs. veins: different materials for different parts of the cave, each region part of the recipe.
Surface brushes — paint a zone by stroke; the stroke becomes a region shape, so it regenerates with the cave.
Material editing — author new block materials (textures, properties) without leaving the tool.
Assets
Structures from the game's blueprint library, placed on your cave floors by rules — count per blueprint, random floor points, random facing. Placement is part of the recipe: it rerolls, undoes, and saves like everything else.
In this cave
Imported assets
Everything you've generated or imported. Blueprints place via + Place; model blocks appear in the scatter/hangings palettes. 🗑 deletes the files permanently; ☁ publishes to the cloud library.
Creatures (rigged)
The game's rigged GLB entities — click one to view it on the stage with its animations playing. Pick an animation from the row that appears.
Blueprint library
Generate with Meshy
Describe it; Meshy makes the mesh (1–4 minutes, uses your Meshy credits), then it lands below ready to voxelize.
Import mesh → blueprint
Pick a GLB (AI-generated or downloaded), choose resolution and material — it's voxelized in the browser and saved as a real blueprint, instantly placeable and previewed on the render stage.
Creatures & rigged assets — GLB models with bones and animations (the vendor asset lane), placed and configured here.
Combat
The combat parameter sheet: one entity's stats, stagger rules and health model beside live math over its real attack timelines. Every knob is a test bench — edits stay in this page's memory and recompute the numbers on the right; ⬇ download hands you the edited JSON to walk through engine review. Saving into the game is an engine/review act — deliberately not a button here tonight.
Combatant
Filesystem truth via serve-studio (/entitylist) — combatants first (docs carrying Stats / Combatant / EntityHealth), everything else under the divider.
Stats & behavior
Every leaf of Stats, Combatant, EntityHealth and VisionDetection. Edits recompute all math live; an accent label means the field differs from disk. Arrays/objects edit as JSON. Shipped Defense values are all 0 today — the engine's defense curve (real, cited in source) only bites once you raise it.
Opponent dummy
The other side of every number on the right. Player weapon truth lives in item definitions (held-item hand stats), so the dummy is configurable, not fake-authoritative — set it to the loadout you're balancing against.
Simulations
Deterministic by construction: the randomness is mulberry32 seeded 1337 — same inputs, same histogram, every run.
Player model
Two bout engines can drive the population numbers, the tier solver and the gauntlet. Simple (default) is the balance-bearing model — Floris spreadsheet semantics: the player attacks for an editable share of the bout (the rest is repositioning/healing, not a reaction draw), eats a flat editable share of enemy hit windows, and Defense stays the engine formula. Dodging, staggers and interrupts are deliberately not simulated here. Behavioral keeps the two-sided reaction sim as an opt-in experimental lens — not for balance claims. The duel and battle replay are feel/demo tools and ignore this switch.
Skill percentile enters the simple model only as modest uptime/dps scaling (uptime ×0.90–1.10, damage ×0.85–1.15, swing rate ×0.90–1.10) — population percentiles still exist, but they measure output, not reads.
Behavioral assumptions (read only while Behavioral is selected): every behavioral constant lives in the one table below, each row labeled with its source — literature rows are shapes borrowed from published human-performance data and are built to be replaced by telemetry one row at a time once the game reports real players; modeling rows are harness mechanics. Entity attacks are drawn uniformly from its hitbox timelines and replayed by their real tick data — AI weighting is deliberately not modeled (that holds for both engines).
Difficulty tiers
Editable targets per tier. The solver searches entityHealth× and entityDamage× inside the envelope — coarse 9×9 log-spaced grid, one half-step local refinement, each cell scored by a 300-player population sim, winner verified at N=1000. Clear rate is measured over the whole population; median clear time over the tier's reference skill band (±10 percentiles).
Battle replay
A sampled bout from the population sim, performed on the stage: the entity's real rig plays its real attack timelines (animation + sound + hitbox volumes) as the log's clock passes each event. The challenger is a deliberate abstraction — outcomes are visualized, movement is not simulated.
⚔ Fight it yourself
A timing duel over the real attack data — spacing and movement are not simulated. The creature draws uniformly from its real hitbox timelines and performs them for real; your inputs are judged on the clock against each window's true telegraph. Every duel lands in the run picker above and banks your reaction times for the behavioral model.
Attacks
Every timeline of this entity holding a Hitbox clip. Damage = AttackDamage × clip DamageMultiplier through the engine's defense curve vs the dummy; stagger = the engine's power>sturdiness gate. Recomputed on every edit.
Headline numbers
Fight report
Tune against a simulated population today; flip the toggle the day telemetry lands — same charts, same targets, zero rework.
Timelines
The choreography rung: where animation, sound, damage windows, particles and camera shake meet on one clock. This is a read-only viewer (v0) over the engine's own timeline files — the multi-track editor is the next build. Timelines are game files; editing them stays server-authoritative territory, decided with the engine team.
Library
Every environment is a folder of game content — what you save IS the shipping format, byte for byte. New environments are born dev-only, invisible to the real game until published.
Environments
Create
Checkpoint
Edits autosave continuously (nothing is ever lost). The checkpoint is your explicit safety line: Save moves it here, Revert returns to it.
Content browser
The whole game lives here: every shipped asset and every creator publish, versioned and hash-verified in the cloud catalog. Search is instant; click any card for its story — versions, files, provenance. Descriptions and tags are editable on your own content (machines wrote the first draft).
checking…
Dashboard
The four question families (doc 11): activity & adoption, content production, AI usage, health & friction — SQL views over telemetry, visible to reviewer/manager roles.
connect & sign in to load…
Help
How this tool thinks.
The document
You are editing a recipe, not blocks. The recipe lives in the environment's own game files; the engine regenerates the cave from it after every change. That's why Reroll is safe (new randomness, same design), why nothing you do can drift from what ships, and why every edit is undoable.
The render window
Drag to orbit · shift+drag or middle-drag to pan · wheel to zoom · Home to reframe on the cave (also resets pan). The game window only renders; all editing happens here.
Preview scale
Work at 64 for ~1-second feedback while sculpting; switch to 192 to see full preview quality. The recipe is identical at every scale.
Diagnostics
About
The Foundry — where raw assets are cast into game-ready stock for Everdeep: materials, meshes, rigged creatures and animations, refined here, shaped in the Forge, stored in the Keep.
Standing on the engine
This tool exists because the Everdeep engine was built right. Its worldgen is shape-in, voxels-out: environments are small Lua recipes over a powerful SDF/CSG shape language, and the engine turns them into worlds. Blocks, materials, particles, creatures and whole mods are data, not code — JSON and GLB files the engine picks up by convention. That degree of data abstraction is rare, and it is what made a live, web-based creation studio possible in days rather than months. Credit where it belongs: Fundy (Floris) and his team built that foundation.
The strategy
"Don't outsource your success." Content creation power belongs in-house and with trusted partners — the studio removes friction instead of delegating the craft. It was built bottom-up: every rung (render, orbit, bake, verbs, assets) proven on screen before the next, with decision records for every engine-level finding.
Found along the way
Building against the real engine surfaced a handful of items now documented for the engine team: speed polish (the editor's bake loop went from minutes to ~1 second — parallel chunk sweep, release-build bake, fast chunk discard, stripped editor boot) and a few bugs (ambience-zone fog values never reaching the shader, a dead sky-color field, the chunk vertex format's tiling limit, a disposal-docs mismatch). All recorded as decision records with measurements.
How it works
You edit a document, never voxels and never raw files. Every slider, verb and placement is a small change to a compact recipe; the engine rewrites the environment's Lua parameters from it and regenerates the cave in about a second at working resolution. The game window is the truth renderer — what you see is the real pipeline, not a preview approximation. Everything is undoable, reroll-safe, and saved as ordinary game content in the Contentstudio mod — never in core assets. Imported meshes (including AI-generated ones) become real blueprints, model blocks with their own materials and effects, or rigged, animated creatures.
Who it's for
Today: vendors, network partners and contractors — the L1 studio tier with the full toolbox. The same protocol powers the in-game god mode (L2) and marketplace (L3) prototypes — see the god-mode prototype for the player-facing face of these features, live on the same engine.
The vision — climbing the ladder
A game is layers, and in Everdeep every layer is data: space (environments) → matter (materials, blocks, props) → inhabitants (creatures, animations) → choreography (timelines — the moment where animation, sound, damage and effects meet) → and above them all the arc: the beats, gates and goals that tell a player why to go anywhere. This studio climbs that ladder one rung at a time. Space, matter and inhabitants are working today; choreography has its first foothold — the Timelines viewer renders the engine's timeline system (thirteen verbs of JSON) as live multi-track choreography, with the editor as the next build; the arc layer is the missing content kind this platform exists to propose. The entire shipped game — 3,000+ assets, every kind — already lives versioned and hash-verified in the studio's catalog.
Two hands
This platform is the meeting of two directions of architecture. Bottom-up: the engine's craft — content-as-data, the shape language, sandboxed Lua, the timeline system — decisions grown upward from what the game needed, done right, by Fundy and his team. Top-down: the platform's hand — starting from where this is going (creators, vendors, a hundred million followers who need doors) and working down through identity, provenance, governance, distribution and the separations of concerns that keep the game pure. Neither direction alone ships a creation platform. They meet in the middle, at the document layer: engine files on one side, the catalog on the other, and this studio as the handshake. When the two hands work together, the unthinkable becomes a build plan. When they fight, the opportunity is what bleeds. That is why the vision is sprinkled through this tool as ✦ sparks — each one a place to say what you see, captured to the platform, becoming the plan.
How this was built
One architect pairing with an AI — a hundred hands, one wheel. Be clear-eyed about what that means: the AI will code anything you ask. That is its danger, not its strength. It amplifies whoever is at the wheel — amplified appetite is entropy at machine speed; amplified architecture is what you're using. Every feature here passed through a mandate written before code, design laws that never bent (never touch core; the engine owns truth; content immutable), decision records for every engine finding, and — above all — refusals: things deliberately not built, or built and deliberately switched off, until the right person had shaped them. The commit count is not the achievement. The restraint is. That is also the policy: the tool isn't handed out — the discipline around it is.
A personal note
Everything in this studio tries to honor the three F's — fun, frictionless, flexible — by tucking the JSON and the Lua behind controls that feel like play. The deeper aim goes one step further: getting the feeling right should itself be fun. A cave, a creature, a beat of choreography — success is how it feels, and this tool exists so that reaching the feeling is joy, not toil. That is also why authoring lives here, apart from playing: the game stays pure, and the making gets a home worthy of it.
A studio like this can only go as far as the vision that feeds it. The engine gave it wings; it is Floris's vision that lets me move mountains — the more of it flows in, the more this becomes. We've had some hard stretches along the way, and I won't pretend otherwise. I've poured my soul into this. It is built with respect for what Everdeep is, and with real hope for what we can make it together. — Anton
The hour factory
Hours of gameplay are not raw assets — they are arranged content: a reason to enter, something gated behind something else, a payoff. A game that needs 20 hours doesn't need one team authoring 20 hours; it needs a machine that lets many creators author them in parallel. That machine is this platform: identity, versioned content with provenance, moderation, distribution and telemetry — so every vendor den and creator world adds hours the core team never had to make. Minecraft's ten thousand hours weren't made by Mojang.
The architecture — who owns what
The separation of concerns this studio is built on: the engine owns semantics — what content means, how it bakes, renders and plays; sealed and authoritative. The tool owns ergonomics — how humans make content: iteration speed, undo, sketch pads, AI assists. The database owns truth and history — what exists, whose it is, which version, what's approved. And the game only ever consumes — content arrives validated and versioned; the runtime never hosts authoring. In-game tools are honest bootstraps, but authoring inside the runtime tangles editor concerns with server authority; moving authoring here keeps the game pure and the server's word final. One protocol, many clients — the game stays the game.
The backend around it
Identity and accounts, an asset catalog with immutable versions and audited moderation, cloud storage — all live today. Login-gated distribution is built and install-tested but deliberately switched off: the package contains the unreleased game, so turning that tap on is Sun Fox's call, not this tool's. Around it: telemetry (what creators build, where they struggle, what players love), knobs (live tuning without patches — and their destination: difficulty as profiles, one piece of content serving every skill tier through parameter multipliers, with telemetry auto-tuning inside envelopes the designer owns), the direction layer (every asset carries its vision, its question thread and its approval — the lead's word is the spec, enforced by role, escalating to the dashboard), the UGC pipeline (player creations flowing through the same validated document format), the marketplace (dens, creator-den exclusives, partner currencies), a Steam interface for distribution and community, and the last arrow: content sync, the engine pulling changed content from the catalog at boot so worlds and arcs ship weekly, no repackaging.
Design laws
Fast first, quality on demand — draft resolution lands in a second; raise it when the shape is right. Document-centric — you edit a recipe, the engine owns the truth; nothing you make can drift from what ships. Content immutable, metadata mutable — versions and hashes are forever; descriptions and tags are living. Background work must be frame-budgeted — a warm-up that steals frames is a bug. And the law this whole studio serves, in Fundy's own words: "you don't need to be good at anything, and you can still make cool things." Every feature must keep an entrance point for someone with no skills and no assets — a drawn stroke becomes a gallery, a sentence becomes a creature, a click becomes a cave.