/render#

/render generates a short video with its own synced audio from a text description. It is the only command that produces a moving result, and the audio is not pasted on afterwards -- the model writes picture and sound together from the same prompt.

/render prompt: a paper boat drifting down a rain-filled gutter, soft rain ambience

Like every generation command it works in servers, in DMs, and through a user install in servers where Eimi is not added. It shares the access rules, the 15-job concurrent limit and the queue card with /imagine.

If you would rather point at a picture that is already in the channel, use the animate right-click menu instead. It feeds the same pipeline with fewer knobs.

The model#

Everything runs through MiniMax H3, a joint video-and-audio model. Output is MP4 at 24 fps with the audio track baked in.

H3 is easily the most expensive thing Eimi does. It is one model on one home GPU, and a render takes the whole card for as long as it runs (see Why it is slow). Budget accordingly, and expect the feature to be switched off from time to time.

The three modes#

Which mode you get is decided entirely by what you attach. There is no mode parameter.

Mode	How you trigger it	What H3 does	Use it when
Text to video	Prompt only	Invents the whole clip from your description	You want something that does not exist yet, or you do not care about matching an existing image
First / last frame	`first_frame`, optionally plus `last_frame`	Starts the clip on your image. With a `last_frame` as well, it interpolates the motion between the two	You already have the picture and want it moving, or you want a controlled A-to-B move
Reference	`reference1` to `reference3`	Treats your images as style, subject and content guidance rather than as literal frames	You want a character, outfit or look carried into a new scene that your images do not show

Locally, reference mode loads a different H3 model file from the other two modes. That is why the two cannot be combined, and why a reference render makes the GPU reload from scratch even if the previous job was also a render.

Frames and references are separate modes

You cannot mix them. Attaching a first_frame and a reference in the same command is rejected with Pick One Mode / Use first/last frame OR reference images, not both -- they're separate H3 modes.

A last_frame on its own is also rejected: Missing First Frame / `last_frame` needs a `first_frame` too -- H3 interpolates the motion between them.

Text to video#

The plain path. Everything in the clip comes out of your prompt, including the sound. This is the mode most affected by enhance, because H3 has a specific prompt format and a bare sentence uses very little of it.

First / last frame#

first_frame pins the opening frame. The clip then moves away from it, so anything you want preserved has to be re-stated in the prompt -- H3 is not obliged to keep the subject on model for the whole clip.

Adding last_frame changes the job from "start here and improvise" to "get from here to there in N seconds". Two frames that are far apart in a short clip produce a fast, sometimes rubbery move. Give it more seconds or pick closer frames.

Attaching a first_frame also changes the defaults: with aspect and resolution left alone, the clip inherits the frame's shape and its pixel count (then gets tier-capped). This mirrors /edit.

Reference#

Reference mode is the "keep this thing, change everything else" path. Three slots are exposed on the command. Locally the graph is wired for up to nine and the cloud API accepts nine as well, but three is what you can actually pass.

References are guidance, not frames. None of your images will appear verbatim in the output.

Multi-shot chaining#

If enhance is on, the local backend is live, and your prompt explicitly asks for separate shots (first shot ... second shot, scene 2, then a shot of ..., three shots), the enhancer splits the idea into an ordered list and Eimi chains them into one continuous clip, carrying motion and audio across each join.

Detail	Value
Maximum shots	4, or the exact number you asked for if you stated one
Duration	`duration` becomes the length of each shot, not the total
Overlap trimmed at each join	22 frames
Availability	Local backend only, and only with `enhance` on

The result card's parameters line shows 3 shots and similar when this happens. Nothing else in the command changes.

Note

This triggers off wording, not a switch. "A fight scene" is one shot no matter how busy it is. "Two scenes total" is two.

Local and cloud backends#

There are two ways H3 can run, and the maintainer picks which one is live from the admin panel. You do not choose per job.

	Local (the default)	API (MiniMax's cloud)
Where it runs	Eimi's own GPU, through ComfyUI	MiniMax's servers
Who can use it	Anyone with bot access	VIP and admin only
Model build	A quantised, pruned build of H3 that fits a single consumer card	MiniMax's own hosted H3
Aspect ratios	Any `W:H` ratio or `WxH` pixel size, snapped to a multiple of 32	Snapped to the nearest of six fixed ratios: `16:9`, `21:9`, `4:3`, `1:1`, `3:4`, `9:16`
Resolution	Your megapixel target, longest side capped at 2560 px	Snapped to `768P` (2.0 MP or under) or `2K` (above 2.0 MP)
Shortest clip	1 second	4 seconds -- anything shorter is raised
Content filter	None	MiniMax's own, and it refuses things
Multi-shot	Yes	No
Rough speed	About 60 seconds of wall time per 1 second of clip at 0.7 MP, scaling with megapixels	Roughly 35 seconds plus 6 seconds per second of clip, plus more at 2K
Give-up point	1 hour	15 minutes
Cost	Electricity and everyone else's queue time	Real money, billed to the maintainer

The API backend is VIP and admin only

While the backend is set to API, a regular user who runs /render gets VIP Only / API video rendering (MiniMax H3) is available to VIP members only. If the maintainer has not configured a MiniMax key, everyone gets Not Configured / The MiniMax API key isn't set up yet. Ask an operator.

The local backend has no such gate. If /render suddenly starts refusing you, the backend was probably flipped rather than your access being revoked.

Cloud renders are billed to the maintainer's personal MiniMax account. That is the entire reason for the gate, and the reason the backend gets switched off again without notice.

Telling which one is live#

The parameters line on the card. Cloud jobs carry an api tag and a resolution tier (768P or 2K). Local jobs carry neither.
The progress bar. On the cloud path the bar picks up a short phase label after the percentage: queued, preparing, generating, or whatever status MiniMax reports. Local renders show a bare bar.
The details panel names the job render (api) or render (local).
The wait. A 5-second clip is about a minute on the cloud and several minutes locally.

The cloud content filter#

The cloud path is moderated and the local path is not. A refusal comes back through the normal error card as:

MiniMax flagged your prompt as not allowed (their content policy).
Try rephrasing it, or use the local backend for uncensored generation.

Named real people, recognisable characters and brands are the usual triggers. There is no appeal and no retry that helps -- rephrase, or wait for the local backend to come back.

All 11 parameters#

Only prompt is required.

Parameter	Type	Default	What it does
`prompt`	text (required)	--	The scene, the action, and any audio you want
`duration`	number	3	Clip length in seconds
`aspect`	text	`16:9`, or your first/last frame's shape	Any `W:H` ratio or `WxH` pixel size
`resolution`	text (autocomplete)	1.0 MP, or derived from your frame	Output size in megapixels
`first_frame`	attachment	--	Start the video on this image
`last_frame`	attachment	--	End the video on this image. Needs `first_frame`
`reference1`	attachment	--	Reference image for style, subject or content guidance
`reference2`	attachment	--	Second reference image
`reference3`	attachment	--	Third reference image
`enhance`	true/false	from your AI features setting	Rewrites your prompt into MiniMax H3's timeline format with AI
`seed`	number	random	Seed for reproducible results

prompt#

The only required parameter, and the one that carries the most weight, because H3 writes the soundtrack from the same sentence it draws the picture from.

Audio lives in the prompt. "A market street at dawn" gets you a mostly quiet clip. "A market street at dawn, distant chatter and a single bicycle bell" gets you the bell. Ambience, music, footsteps, impacts and speech all go here.
Describe motion, not just appearance. A still description gives you a nearly still clip. Say what moves and how the camera moves with it.
Dialogue works but needs asking for. H3 will not invent speech unless you request it. If you want a line spoken, say so and quote the line.
On-screen text goes in double quotes. That is the convention H3's prompt format uses, and the enhancer follows it.

There is no negative prompt on /render.

duration#

Clip length in seconds. Default 3.

The value is clamped to 1-15 first, then capped again by your tier (see Tier caps), then translated into a frame count. It is not exact: H3's latents live on a fixed frame grid, so the frame count is rounded up to the next valid value and the delivered clip can run slightly long. Ask for 3 seconds and you get 3.04. Ask for 5 and you get 5.17. The card reports the real length.

On the cloud backend the floor is 4 seconds instead of 1.

Short cloud clips are silently lengthened

The cloud API will not make a clip shorter than 4 seconds. Ask for 2 and you get a 4-second clip, but the card still says 2 seconds. This only affects the API backend.

Duration is the single biggest lever on how long you wait and how large the file is. Both scale roughly linearly with it.

aspect#

Two grammars, the same ones /imagine accepts:

Form	Example	What happens
Ratio	`16:9`, `9:16`, `2.35:1`	Sized to hit your megapixel target at that shape, then snapped to a multiple of 32
Pixel size	`1280x720`	The literal size is honoured (snapped to /32). Your `resolution` is ignored
Preset word	`landscape`, `portrait`, `square`, `ultrawide`, `standard`	Shorthand for `16:9`, `9:16`, `1:1`, `21:9`, `4:3`

Ratios more extreme than 32:1 are clamped, and the longest side is capped at 2560 px locally, so a very wide pick lands a little under its megapixel target.

Anything else gives Invalid Aspect Ratio / `{x}` isn't a ratio I understand. Use `W:H` like `16:9`, `9:16`, or `2.35:1`, or a pixel size like `1280x720`.

If you attached a first_frame and left aspect alone, the clip takes that frame's exact shape.

On the cloud backend none of this precision survives: your ratio is matched to the nearest of the API's six fixed ratios, and when you attach any image the API derives the orientation from the image and ignores aspect entirely.

resolution#

A megapixel target, not a pixel size. The autocomplete offers only the tiers your tier is allowed:

Choice	Who sees it
`0.4 MP (draft, fastest)`	Everyone
`0.7 MP (low)`	Everyone
`1.0 MP (≈768P)`	VIP and admin
`3.7 MP (≈2K, slowest)`	VIP and admin

You can type a value by hand instead of picking one. Typed values are clamped to 0.1-4.0 and then snapped to your tier, not rejected -- there is no error for asking too big. On the cloud backend the value snaps again to 768P (2.0 MP or under) or 2K (above 2.0 MP).

The nominal default is 1.0 MP, so in practice a regular user who leaves resolution alone gets 0.7 MP after the tier snap.

Cost scales with megapixels roughly as it does with duration, and the two multiply. A 15-second 3.7 MP clip is not a slightly bigger job than a 3-second 0.4 MP one, it is an enormously bigger one.

first_frame#

An image that becomes the opening frame of the clip. Switches the job into first/last-frame mode.

Also acts as a default for aspect and resolution when you have not set them: the clip inherits the frame's proportions and its pixel count. Anything you type wins over the inherited value.

last_frame#

An image that the clip ends on. Requires first_frame -- on its own it is rejected, because H3 interpolates between the two rather than working backwards from one.

With both frames set, the prompt describes the journey rather than the destination.

reference1, reference2, reference3#

Up to three images used as style, subject and content guidance. Switches the job into reference mode, which cannot be combined with frames.

The slots are not ranked -- there is no "primary" reference. Fill however many you have.

enhance#

Rewrites what you typed into H3's own T2VA timeline format before generating. Defaults to your ai_features setting in /settings.

The rewrite produces three fields rather than a sentence:

Field	What it carries
`integrated_multimodal_description`	The visual timeline: style, opening composition, what happens, how the camera moves
`overall_soundscape`	Ambient sound, physical action sound, non-verbal human sound
`non_diegetic_music`	Background score only, or `N/A`

That structure is most of why enhance matters more here than on the image commands. H3 was trained on this format, and a bare sentence leaves the soundscape and score fields empty.

Enhancement is tried on Gemini first and falls back to the local LLM. It runs inside the queue worker when your job starts, not when you press enter, so it does not delay the queue card. It is also what enables multi-shot chaining.

Turn it off when you have already written a proper H3-format prompt, or when you want the exact wording you typed and nothing else.

seed#

Fixes the noise. Same prompt, same settings, same seed gives the same clip on the local backend. Out-of-range values (below 0 or above 4294967295) are replaced with a random one rather than rejected.

Leaving it off means every 🔄 re-roll genuinely differs. Setting it explicitly is how you change one thing at a time.

The draft-then-commit loop

Video is slow enough that guessing is expensive. Find your prompt at 0.4 MP and 2 or 3 seconds until the motion and audio are what you wanted, note the seed from the details panel, then re-run the same seed at the length and size you actually want.

Tier caps#

Duration and resolution are limited by who you are, not by which backend is live. Since the cloud backend is VIP-only anyway, the caps only ever bite on the local path.

Tier	Resolution tiers offered	Maximum duration
Regular user	`0.4 MP`, `0.7 MP`	10 seconds
VIP and admin	the above, plus `1.0 MP` and `3.7 MP`	15 seconds

Disallowed picks are quietly snapped down, never refused. Ask for 15 seconds at 3.7 MP as a regular user and you get 10 seconds at 0.7 MP with no complaint, no warning and no note on the card. The only way to see what actually ran is the card's parameters line and the details panel.

The caps exist because a long, large render occupies the only GPU for a long time and nobody else's jobs run while it does. They are a queue-fairness measure, not a paywall.

Attaching images#

Rule	Detail
Must be images	A non-image attachment gives Invalid Attachment / `{filename}` isn't an image. Frames and references must be images.
Frames or references, never both	See the three modes
`last_frame` needs `first_frame`	Rejected otherwise
Reference slots	Three exposed, three is the practical maximum
Odd formats	On the local backend every frame and reference is converted to a plain single-frame PNG first, so exotic stills decode and animated WebP or APNG get flattened to their first frame
Cloud path	Your Discord attachment URLs are handed to MiniMax, which fetches them server-side. Nothing is converted
Upload trouble	Upload Failed / `Couldn't hand one of your images to the render backend. Try again.`

Attaching anything makes Eimi acknowledge the command before doing the work, so that reading and uploading your files cannot time the interaction out. A short pause before the queue card appears is normal and does not mean anything is wrong.

What you get back#


Format	MP4, 24 fps, audio track included
Player	Discord's inline video player
Duration accuracy	Rounded up to H3's frame grid, so the clip is equal to or slightly longer than you asked
Live preview frames	Off, always
Give-up point	3600 seconds (1 hour) on the local backend, against 600 seconds for every other job type. 900 seconds (15 minutes) on the cloud

No preview images while it renders

Every other command drips a live preview into the card as it goes. Render jobs cannot: H3's combined video-and-audio latent crashes the preview step, so previews are forced off for /render regardless of your show_previews setting. You get the progress bar and nothing else.

The bar itself is real, but coarse. A local render samples in 20 steps, so it advances in 5% jumps with a long, silent gap between each one. A multi-shot chain labels its progress Shot 1/3... 12/20 and spans the whole chain rather than restarting per shot. The cloud path drives its bar from an estimate and overrides it whenever MiniMax reports a real percentage.

If the clip is too big for Discord#

Eimi knows the file size, the clip length and your server's live upload limit before it sends anything, so there is no upload-and-retry loop. Instead there is a three-rung ladder:

Rung	Condition	What you get
1	The file already fits	Sent as-is, inline
2	Over the limit, and ffmpeg is available	One re-encode pass at a bitrate computed to land at about 92% of the limit, then sent inline
3	Over the limit and rung 2 cannot help	The card arrives with no file and a warning line

Rung 2 gives up rather than producing mush: it reserves 64 kbps for the audio, and if the video bitrate that leaves would fall below 120 kbps it declines. Long clips at large sizes hit that wall.

The rung 3 message reads:

⚠️ clip is 31.4MB, over this server's 10MB upload limit.
try a shorter duration or smaller resolution.

The limit quoted is your server's real current one, which rises with boost level, and is 10 MB when Eimi cannot determine it. Shortening the clip helps more than shrinking it, because bitrate budget is a function of duration.

The result card#

Deliberately thin. Most of the buttons on an image card mean nothing for an MP4:

Button	What it does
🔄	Re-roll -- same settings, new seed
🔍	Details -- the full parameter and timing dump
🗑️	Delete the result
📤	Replaces 🗑️ on private results, and re-posts the clip publicly

No ⬆️ upgrade, no 🎲 remix, no 🎨 edit, no ✨ detailer. A re-roll re-reads your server's upload limit at the time you click, so re-rolling in a different server can change the size ladder outcome.

The parameters line above the video shows 🎬 followed by the duration, the shot count when there is more than one, the aspect ratio when it is not 16:9, clickable links back to any frames or references you attached, the api tag and resolution tier on cloud jobs, and your seed if you set one.

Why it is slow#

Worth understanding, because it explains most of the odd behaviour around /render.

The local H3 stack does not share the GPU. Before a render starts, Eimi evicts every other model from the card and then polls until roughly 21 GB is actually free, re-issuing the eviction if it lags. If even a fraction of the model spills to system memory, ComfyUI streams weights back and forth every sampling step and a 90-second job becomes a 10-minute one.
The job right after yours pays for it. The image models have to reload from disk once a render finishes.
Renders ignore the GPU power cap. Other jobs get throttled; a render does not, because throttling roughly triples its runtime.
Sampling is fixed at 20 steps. There is no steps parameter on /render.

None of this is tuned for throughput. It is one card in somebody's house being asked to do the least card-friendly thing in the bot.

Troubleshooting#

What you see	What it means
Access Denied / `You don't have permission to use the bot here.`	Bot access, not a render-specific problem. See Access
VIP Only / `API video rendering (MiniMax H3) is available to VIP members only.`	The cloud backend is live and you are not VIP. Wait for the local backend, or ask the maintainer
Not Configured / `The MiniMax API key isn't set up yet. Ask an operator.`	The cloud backend is live but has no key. Nobody can render right now
Job Limit Reached / `You have N job(s) in the queue. Your limit is L.`	You already have the maximum number of jobs queued. The default limit is 15
Invalid Aspect Ratio	`aspect` was not a `W:H` ratio, a `WxH` size or a preset word
Invalid Attachment / `{filename}` isn't an image.	One of your frames or references is not an image file
Missing First Frame	You passed `last_frame` without `first_frame`
Pick One Mode	You mixed frames and references
Upload Failed / `Couldn't hand one of your images to the render backend.`	ComfyUI would not accept one of your images. Usually transient, try again
`Failed to prepare the render. Please try again.`	The workflow could not be built. Usually a ComfyUI-side problem
`Workflow system not available. Please try again later.`	ComfyUI is not reachable at all
`MiniMax flagged your prompt as not allowed (their content policy)...`	Cloud content filter. Rephrase, or wait for the local backend
`MiniMax couldn't make this video: {reason}`	The cloud job failed for a reason MiniMax gave
`The video job failed on MiniMax's side.`	The cloud job failed and gave no reason
`MiniMax rejected the request ({reason})`	The submission itself was refused. Often a key or quota problem on the maintainer's account
`The video took too long and timed out.`	The cloud job ran past 15 minutes
`The video service errored out. Try again in a bit.`	Network or cloud-side failure with no detail
⚠️ `clip is X MB, over this server's Y MB upload limit`	Not an error. The clip rendered, it just could not be attached. See the size ladder
The bar sits at one number for a long time	Normal. A local render is 20 sampling steps, so it moves in 5% jumps with long gaps and shows no preview frames
The clip is a bit longer than you asked	Normal. See duration
Your 15-second 3.7 MP request came back short and small	You are not VIP. See Tier caps

Content-policy and quota failures do not ping the maintainer. Everything else does.