Make a game
feel like yours.

Make the first change small

Replace one symbol.

Open your project’s Lab and choose the Art tab in the Lab bar. Use the search and Show filter in the Art control row to find an image slot declared by your game. Inspect its current artwork and any size or format requirements before choosing a replacement.

1. Click Replace image on the chosen slot, or drop one image directly onto its tile. Use an image you have permission to use.
2. The editor uploads the file and saves its binding to that slot in one action. Wait for the saved confirmation; you do not need a separate Save button.
3. With the Auto preview switch in the control row on, each saved replacement updates the running game when the build supports live updates; other builds restart the preview. With it off, save several images, then choose Apply to preview, or Reload preview on builds that restart. Check the symbol at its actual on-screen size.

Use the slot’s Restore original control if you want its original artwork back. This changes that binding; it does not reset the whole project.

Agents using a project key, teammates and your other browser tabs can also save artwork. Those slots show Changed elsewhere and a time. With Auto preview on, the running game picks them up without restarting on builds that support live updates; other builds keep the previous image until you choose Reload preview. Choose the count in the control row, such as 3 changed, or Changed elsewhere in Show, to list only those slots. Opening a marked slot changes its marker to Reviewed; a slot changed while the Lab was open opens with Before outside change beside the current image. Mark all seen clears the markers. To hand work to an agent, Copy brief copies up to 60 shown slots as plain text, with their sizes, revisions and the MCP arguments to use, and Copy slot brief in the image inspector copies one slot. Help → Connect an agent opens your studio’s Developer access page to create a project key.

Give the change a voice

Choose a cue and listen in context.

Open the Sound Lab tab, find a declared cue with the search in its control row and audition its current sound when a playable asset is available. Drop a replacement file directly onto that cue row, or click its current take to choose a file. The editor uploads and binds it in one action. Adjust its level with the row’s volume control; releasing the control saves the level.

You can also upload several sounds through Browse files, then drag an uploaded take onto its cue row. A general library upload leaves the cue unchanged until you bind the take.

Preview the cue on its own first. Enable sound in the game’s own controls, then trigger the matching event, such as a spin or a win. Hearing an audition confirms the asset plays; the game event confirms that the cue works in context.

Keep the first pass simple: one spin sound and one win sound are enough to hear whether the direction fits.

Movement belongs with the artwork

Tune a supported Motion state.

In the Art tab, open Motion for a slot that declares animation support. Choose an available state, such as idle or win, and adjust the presets and timing that the game exposes.

1. Choose the state and adjust its preset, duration, intensity and easing where available.
2. Choose Save motion and wait for confirmation. Sampling uses the saved revision, so save a draft before judging it in the game.
3. Choose Sample saved motion, inspect the result and check its acknowledgement. Adjust and save again if needed.

The available states and controls depend on the game. For your own rigs, animation timelines and supported Spine imports, open Animation Lab.

From the first bone to the finished clip

Create an animation in Animation Lab.

Open your project’s Lab, then choose the Animation Lab tab beside Art in the Lab bar. Animation Lab fills the workspace below the bar. Drag the panel dividers, or focus one and use the arrow keys, to give the canvas, hierarchy, inspector or timeline more room. Dopesheet and Graph share your saved timeline height. Layout preferences stay on this device; Reset layout restores the defaults. On smaller screens, use Scene, Timeline, Layers, Inspector, Cues and Mixer to switch panels. If the tab is missing, check that your installation has Animation Lab enabled and your role includes View animations. Creating and editing animations also needs the matching permission and available editor capacity.

1. Open a saved rig from Project, or choose New rig. Use Project assets to copy a PNG from Art Lab or a supported WAV from Sound Lab. You can also import a local PNG. Copying an asset into a rig keeps its source independent of later replacements in the Lab.
2. Choose Setup pose. Select a parent and use + Bone or + Sprite to build the hierarchy. Position, rotate and scale your layers on the canvas or in the inspector. Names and choices open in inline forms with Create and Cancel actions.
3. Switch to Animate, choose or add a clip, and move the playhead. Changing an animated field adds a key; its diamond button keys the current value. Play or scrub the clip, adjust its timing and use Undo/Redo to compare edits.
4. Choose Save to project and wait for confirmation. For a game that declares animation hooks, open the game-binding controls and select an exact saved rig version and clip or mix. Choose an event declared by the game, such as Board win, symbol, reel or feature events, and whether to play authored sound after a game gesture. Events appear only where the game declares and implements their adapters. Save the binding, then preview the matching game event. Saving a newer rig does not silently replace a version already bound to the game.

Build and reuse a rig.

Parent bones and sprites, edit bone lengths, duplicate or reparent subtrees, and manage attachment variants and named skins. Attachment keys can switch an image or hide it during a clip. Export rig packages a reusable rig with its dependencies; Import rig adds a separately named copy with its own identities and animations. Invalid references and incomplete copies are reported before an edit is applied. A rejected rig file names the fault by its JSON path and reason, and suggests the intended name for a close misspelling. Saving applies the same checks on the server, which also refuses constraint cycles that playback cannot load.

Shape meshes and paint weights.

Create and triangulate meshes, edit their outline, vertices and UV coordinates, and bind them to bones. For meshes created and bound in the editor, paint weights in the mesh graph and lock influences. Imported meshes with bone-local influence points also support a brush on the scene canvas and editing those points on the canvas or numerically. Setup changes the rest geometry; Animate creates free-form deformation keys. Linked meshes share geometry, including across compatible sprite owners, and can share deformation or keep their own. Use Edit source mesh to navigate to shared geometry, or unlink to keep an independent editable copy.

Refine timing, curves and pose spacing.

The dopesheet supports multiple-key selection, range selection, snapping, zoom, copying, retiming and clip duplication. Use Graph to adjust scalar curves and Bezier handles, box-select visible keys or link adjacent tangents. Enable Normalize curves to compare channels with different units on a shared percentage axis. Each curve uses its full clip range, including easing overshoot; key labels retain the original values. Moving selected keys by 10% moves each by one tenth of its own range. A flat curve sits at 50%, with a full scale of one displayed unit. Ghost poses show earlier and later silhouettes while you scrub. Mesh deformation, constraint and physics keys participate in the timeline; portable keyframe paste asks you to map compatible rig parts when identities differ.

Tint, flash and blend.

Under Colour & blending in the inspector, set a layer’s Tint with the colour picker or exact red, green and blue values; children inherit it. Dark colour colours the art’s shadows: White flash keys a short flash to white at the playhead, and a warm dark colour lifts shadows into a glow. Both can be keyed in Animate and appear as Colour and Dark colour lanes in the dopesheet, with separate red, green and blue curves in Graph. Sprites also have a Blend mode: normal, add, screen or multiply. The stage and ghosts draw them as the exported runtime does. Opening an older rig upgrades it to format version 13; a rig that uses none of these features saves without them.

Add rig controls and secondary motion.

Use one- or two-bone IK to reach a target, transform constraints to follow another bone, or editable paths to guide followers. Animate targets, path owners and constraint parameters, and inspect unreachable-target diagnostics. Physics · secondary motion adds springs to bones: set frequency, damping and travel/rotation stops in Setup, then key gravity and translation/rotation mix in Animate. Scrubbing, restarting and looping reproduce the same simulated motion. These are ReelGrove’s native physics controls; importing Spine physics is not supported.

Control what appears in front.

Drawing order lists sprites from back to front. Move a sprite one step or send it to either end. Setup changes the initial order; Animate keys the whole scene order. Use Alt + Up/Down for adjacent moves, or key the setup order to restore it later. Order switches happen exactly at their keys. Polygon clipping masks follow their owner bones and keep their assigned sprite targets as drawing order changes.

Layer clips and time events and sound.

Save mixes with weighted override or additive layers, inherited bone masks, crossfades and queued clips. Preview the result in Mixer. Drawing order is a global channel and is not limited by bone masks. In Cues, add named events and audio with source trims, fades, gain and waveforms; use the Sound Lab library for supported project audio. Seeking stays silent. Events can carry optional integer, number and text values, which exported runtime event callbacks receive. Clip loops marks a clip that exported runtime scenes loop by default; saved mixes, presentation scenes and game bindings still play it once. Clip tags label clips, such as idle or win:big. Saved bindings connect animation to declared game hooks; game logic owns gameplay completion and settlement.

Bind a saved rig to an actual game event.

In Game animations, refresh the declared events, choose Game event and select Choose open rig’s saved version. Pick its clip or saved mix, appearance and sound, then choose Bind saved version. Each event has its own exact version and history; later rig edits do not change an existing binding.

The available events come from your game’s retained source. A game can declare board wins, individual symbol landings or wins, reel stops or anticipation, bonus transitions and specific win tiers. The list comes from that game’s declaration; replay a recorded outcome to check that each hook is connected. Existing starter projects keep their original declarations when newer templates become available.

Use Preview saved binding to inspect the actual game placement, then replay saved outcomes and check skip, turbo, reduced motion and sound. Games with concurrent symbol or reel effects have shared rendering and audio limits; smaller rig canvases and media leave room for more effects. Loading does not play sound, and the preview button cannot unlock game audio. Use the game’s own Sound or Spin control. Decorative animations never decide a payout or hold up game completion.

Take the rig and runtime with you.

Download JSON keeps an editable document with embedded media. Export player creates a standalone preview; Export atlas player packs supported images into texture pages. Export package includes the editable rig, original media, playback runtime, runtime source, examples and notices, with an optional atlas. The runtime draws tint, dark colour and blend modes with WebGL or WebGPU. The editor stage and exported player render at the device pixel ratio; runtime scenes can follow it with resolution: 'auto' and use optional mipmaps for art drawn well below its texture size. Test the exported result in your game’s own integration.

The included runtime project-use license permits commercial projects, modifications and distribution as part of those projects. Those permissions continue after a ReelGrove subscription ends. Keep the included license and third-party notices; artwork, audio and other third-party rights remain separate. The export license covers the included runtime, not distribution of the hosted editor as a separate product.

Continue with an existing rig

Import a supported Spine export.

Choose Import Spine in Animation Lab. The supported JSON export profiles are 4.1.17 and 4.2.22. Use files and images you have permission to use. Proprietary .spine project files and binary .skel exports are not supported.

1. Select the JSON and its original PNGs, or its .atlas file and PNG pages. Choose folder retains nested image paths. The supported atlas reader handles trimmed regions and quarter-turn rotation, using straight-alpha PNGs and Linear/Linear sampling.
2. Review the compatibility result, rig name and canvas origin before importing. If rounded source time handles need an adjustment, the form explains it and requires a separate opt-in; it is never applied silently.
3. Choose Import Spine rig. Inspect every clip and skin, scrub key boundaries, then save the editable native rig to your project. The complete insertion can be undone once; Cancel leaves the open rig intact.

The importer supports region attachments; unweighted and supported weighted meshes with deformation; skins and attachment switches; direct linked meshes with supported shared or independent deformation; plain one- and two-bone IK, including partial and animated one-bone mixes within the checked angle and scale limits; static unweighted clipping; and slot drawing-order timelines. Imported bone-local mesh influences remain editable.

Current document limits include 256 scene nodes, 32 image assets, 256 clips and 20,000 keys across the document. Physics adds its own simulation-work limits, and imported attachment variants can expand one source slot into several native sprites. The compatibility report checks the resulting native document and its media before insertion.

Look at the whole game

Preview, then read the checks.

Use the private game preview to play with test credits; the preview toolbar keeps Test credits · no cash value in view. The viewport selector in that toolbar offers Desktop (1200×675), Laptop (1024×576), Popout S (400×225), Popout L (800×450), and Mobile L/M/S (425×812, 375×667, 320×568), plus phone portrait, tablet and Fit to window. These presets also appear in the Screen selector of separate game-preview dialogs. The game receives the exact selected pixel dimensions and scales down to fit your workspace; the size readout beside the selector shows the pixel size and any scale. Changing screen size keeps the current session and round. Listen for the cues you changed and watch the saved artwork and motion.

Open the collapsible Session settings sidebar beside the game preview in Frontend, Sound, Art or Animation Lab. Changing currency or starting balance starts a fresh test session. New session starts another with your current settings. Language, device and social settings reload the same session. Check connection reads its current balance and the game’s available bet ladder; it does not reset your credits. Use the reset controls to restore the preview defaults. Focus in the preview toolbar hides the Lab bar and keeps Session settings beside the game; press Esc or choose Exit focus to leave.

In Frontend → Saved test scenarios, save an exact published outcome and its input identities. Reopen that book to discuss it again; the interactive preview uses current creative state. In Studio release review, capture a candidate with matching scenarios, then collect comments and human approval against that exact version. Changed inputs are marked stale. On installations with hosted execution enabled, the candidate’s Browser observations record isolated runs of its frozen frontend and saved outcomes. A studio approval does not grant Engine approval. Read the scenario and release workflow.

Use Find a published outcome to search for zero payouts, an inclusive payout range, the published maximum or an exact recorded event type. Results show exact IDs and draw weights, including zero-weight records. Use this outcome fills the capture form; review its name and browser settings, then save explicitly. Searching never runs the game. Observer support follows the starter release in each project; a newer default does not retrofit earlier studio templates.

Use a completed browser observation as a baseline, then compare it with another retained run. Review changed payouts, events, errors and screenshots before deciding whether a change fixes the same case. Requested profiles and actions remain separate from recorded browser behavior, so an incomplete failed run can still be compared without implying its controls succeeded.

After changing a build, open a saved scenario and choose Reuse on current build. Review the current outcome against the original, including the book, payout, event positions, input identities and profile, then explicitly save the reviewed scenario. The original and its observations remain intact; a reused expectation still needs a new browser run.

Use Frontend → Named regression suites to group exact saved scenarios under stable case keys. Save immutable versions, inspect changed inputs and choose the precise version for a release candidate. Open captured release continues into review and separately started browser checks. After a lost response, recover the saved suite request before creating another.

In Frontend → Profile and action matrices, save viewport, locale, motion and action combinations, select exact outcomes and review every resulting cell before capturing the complete set as a suite. Run that suite separately; unsupported controls stay visible as failed checks.

Use readiness policies to connect structured requirements and an exact suite to a release candidate. Reviewers select the observations and screenshots they inspected, record requirement notes and save a decision with any explicitly permitted exceptions. Earlier evidence remains intact when the project changes.

Game source and general game settings are not editable in the customer Lab. Where import and activation are both enabled, a permitted editor can validate a separately prepared bundle and activate the resulting build through the project’s import workflow.

Give each person the right tools

Invite your collaborators.

Open Team, enter your teammate’s email and choose a role. Review the permission checkboxes before creating the invitation, then share its invitation link with that person.

Use Art designer, Sound designer, Animator, Frontend developer or Math designer as a starting point. A Studio admin can manage projects and invite or remove teammates. Only the owner can change members’ permissions and manage billing. Studio roles do not grant platform administration access. Review-only members do not consume editor capacity; editing roles do. An active free trial includes three editor seats, including the owner, and free reviewers. A pending invitation does not reserve a seat; one must be available when an editor accepts it.

The presence pill at the end of the Lab bar shows who has the project open. When another person saves a change, the Lab refreshes saved Art and Sound assets while keeping your drafts and game preview open. A small Saved assets refreshed notice appears at the bottom left and closes after about 10 seconds; when Art slots changed, its Show changes lists them as Changed elsewhere. If an operation is still running, the same notice says saved changes are waiting; use Refresh saved assets in it once the operation finishes, or close it with ×. If a save conflicts, review the current binding before deciding what to save next.

Recover an Animation Lab draft.

Open Project → Recovery on this device to review a tab’s retained draft or unfinished save. Recover session opens the reviewed copy in the current tab; recovery does not automatically send an old save. For a lost save response, use the offered exact-request retry and inspect the confirmed result before saving later edits.

Project history retains saved versions for review and explicit restore. Find earlier revisions locates rigs saved before a project reset. The recovery manager also lets you review, download or explicitly delete local copies from earlier revisions. Copies belong to the same signed-in account and project; current permissions still apply. Browser storage can be cleared, so save to the project or download JSON for a lasting copy.

Take the finished work with you

Capture and download an export.

1. Save the artwork, sounds, Motion presets and Animation Lab rigs you want included. Save any game-animation bindings to the intended rig versions.
2. In the Lab, choose the project name at the top left to open the project menu, then choose Export game. You can also choose it on the project in Overview. Select Standalone game, confirm the capture and choose Create export.
3. Review the captured project revision and saved change versions. Wait for the export to be ready, then choose Download ZIP.
4. Keep the archive and its included source and notices. Build and verify it in your own development environment before submission.

An export captures a point in time. Later Lab changes require another export. Supported exports run independently of ReelGrove; downloading an export does not grant Engine submission approval.

The standalone ZIP includes the captured Art, Sound, Motion and game animation settings, their required media, and saved animation documents as editable JSON files. Import new build cannot restore this ZIP as a complete Lab project.

Keep an editable project archive.

Retained hosted browser observations include their frozen game inputs, recorded results and screenshots. Failed checks remain part of that evidence. Offline verification checks the captured files; imported records do not transfer another studio’s approvals.

Choose Portable project to capture development files, current Lab metadata, all uploaded assets, every retained animation version and branch, review lineage and current-revision scenario and release records. Verify and unpack it with bundlepack for offline recovery. Older archives include only their originally captured history.

Portable archives also retain complete profile-matrix history and original readiness policies, decisions and their selected test evidence. Named suite versions retain their exact referenced scenarios, books and captured-revision release links in the portable archive. Imported suite history remains original evidence; a restored project needs its own authorized suite and release decisions.

Where restoration is enabled, prepare the archive and restore a new editable project through Import existing game. Review the validated candidate and explicitly choose Restore project. Imported decisions remain historical evidence; review and test the destination independently. You can also create reusable studio kits for deliberate import through the destination Lab.

If the project menu in your Lab shows Studio kits, upload a kit, inspect its complete contents and review the destination plan. Installation requires a separate confirmation of added files, reused assets, fresh animation identities and storage. Use Recover saved request after an interrupted response. Existing Lab work is preserved; configure new game bindings and review playback yourself.

Make an independent editable copy.

On installations with cloning enabled, choose Clone project from the project menu at the top left of the Lab. Save open drafts, name the new project and confirm Create editable copy. The copy captures the current source and saved Lab work in the same studio, then validates and restores it before offering Open copied project.

Use Recover saved request after an interrupted reply; it keeps the original capture. Your copy history remains readable when editing expires. Unfinished copies expire after one hour and can offer a separate cancellation confirmation. Imported QA, review and animation history is retained; the new project needs its own tests and approvals. Read the copy and recovery workflow for exact limits.

Edit and rebuild a game locally.

1. Choose Development bundle in the export dialog and download the ready ZIP. It contains your current source, preview and production builds, published math and build instructions.
2. Extract the ZIP into a private working folder. Follow source/development/README.md and the included source instructions to edit and build both frontend targets locally.
3. Keep dependency installs and build caches outside the finished bundle. Download and verify bundlepack for your Linux or WSL2 environment, then follow its setup instructions to package the completed bundle as a .tar file.
4. Open Import new build for the same project, upload the TAR, review validation and activate the build when ready. Then check the game in the Lab and preview.

Your uploaded assets and saved Art, Sound, Motion and Animation Lab work stay in the original project. Activate the rebuilt game in that same project to preserve them. Development downloads contain empty Lab overrides and omit animation documents; importing into another project transfers the source, builds and math without that saved Lab work. After activation, check that the new game still declares the hooks needed by your animation bindings. Import and activation must be enabled for your installation and your role.

Keep your place

If something gets stuck.

A tool is missing or editing is disabled.

Without current editing capacity, the Lab bar shows a Read-only chip, or Editing ended once your trial or paid editing access has expired. Choose it to read why; it links back to your studio, or to your plan if you manage billing. Ask your studio owner to check your permissions, trial or subscription status, and editor capacity. The Lab only shows disciplines you can read. If access changed while the page was open, a row under the Lab bar says Your access changed; choose Reload workspace or sign in again to refresh it.

Your connection dropped during an operation.

Return to the same project and inspect the operation’s history and status. Use its offered recovery or retry action. For an uncertain activation, check whether it was admitted before starting another request.

Animation graphics could not start.

Animation Lab and its exported players need working WebGL or WebGPU support. Enable graphics acceleration in your browser, reload, or try another browser. For complex rigs, hardware acceleration helps keep playback smooth; software rendering can run more slowly. Atlas players can reduce texture switching.

A preview expired.

Reopen the project’s preview from the Lab. Preview links are private, temporary and tied to your session; share studio invitations with teammates instead of copying a preview URL.

A preview is taking a while to open.

The game area shows whether the workspace is being prepared, your private preview is starting or its window is loading. If the window is still loading after 30 seconds, you can keep waiting or use Reload in the preview toolbar; a later load clears the message. If the window opens with an error, follow the message shown there.

An operation says it needs review.

Keep the operation ID, the visible error or status, the time it occurred and a short description of the steps you took. Send them to support@reelgrove.net. The platform administrator can inspect work status; your studio owner does not automatically have platform admin access.

Passwords, recovery links, project keys and private preview URLs are not needed in a problem report.

Contact support ↗ · Return to your studio ↗ · MCP setup and troubleshooting ↗ · Downloads ↗

Your account

A sign-in that works for you.

Sign in with your email address and password, or use a passkey you have added to your account. Open Sign-in & security to add a passkey after verifying your email. Use a recent sign-in when adding your first passkey, and an existing passkey when adding another.

Your device or password manager handles passkey verification. Platform administrators use a passkey to open the admin panel and confirm individual actions.

If you lose access, choose Forgot password on the sign-in page. Email recovery signs out previous sessions and removes existing passkeys. Add a passkey again once you have recovered your account.

Keep ReelGrove close

Find us on Google.

Choose ReelGrove as a preferred source on Google ↗ to help you find our public content in Search. The link opens Google’s source preferences in a new tab. If ReelGrove is available, select it and confirm your choice there.

You can also use Prefer ReelGrove on Google in the site footer. This preference belongs to your Google account; it does not change your ReelGrove account or guarantee that our pages appear in your results.