Moderation depth vs builder expressiveness

Dyno is the veteran of Discord moderation, with 18+ AutoMod rule types and 25+ action log events. BotShade trades that catalog breadth for builder depth — a typed visual workflow, persistent variables, an AI command builder, and a plugin marketplace in the same dashboard.

Custom Commands — DSL vs variable interpolation

Dyno's Custom Commands use a variable interpolation model — {user}, {server}, {avatar} plus canned calls into existing Dyno commands — without language-level conditions, loops, state, or external API calls. BotShade's custom command builder assembles about 60 node types on a visual node editor, including conditional branches, loops, error handlers, function definitions, and function calls, and runs node, configuration, and function validation before save.

Persistent variables and state paths (typed vs none)

BotShade gives you a typed persistent variable catalog scoped to the bot, the server, individual users, and per-server members — string, number, boolean, object, array, url, money, time, plus typed Discord references — managed in the GUI and protected from lost updates by atomic read-modify-write with row-level locking. Dyno's command model has no first-class notion of state, so commands cannot share values at the language level.

An AI that writes commands (BotShader AI)

BotShade turns natural language into a command build plan and applies it to the visual node editor through a preview → apply flow that already ships today, with edits driven from the AI assistant sidebar. Dyno does not offer AI features — AutoMod and Custom Commands are entirely rule- and template-based.

Plugin marketplace vs a closed module set

Dyno ships a fixed catalog of around 30 modules — AutoMod, Action Log, Forms, Levels, Starboard, and so on — without an SDK or marketplace for community modules. BotShade's module marketplace wires the full path end to end: each module declares its settings, users configure them in a dedicated panel, those settings flow safely into the module's logic, and runtime state stays in sync with the bot.

Moderation depth — Dyno's home turf

Dyno's AutoMod covers 18+ rule types — AllCaps, Bad Words, Newlines, Duplicate Text, Emoji Spam, Image Spam, Invite Links, Known Phishing Links, Mass Mentions, Spoilers, Masked Links, Sticker Cooldown, Zalgo Text, and more — each with its own action and log channel. Action Log covers 25+ events including Bulk Delete, Member Timeout, Channel Update, and Voice Move. BotShade's moderation centers on ban, kick, timeout, mute, and per-command access controls, which is narrower in rule coverage.

Forms and Appeals — also a Dyno strength

Dyno's Forms combine short answer, paragraph, multiple choice, and checkbox fields with Staff Application, Appeals, and Feedback templates, public URLs at dyno.gg/form/{id}, Submission Viewer and Manager roles, and tight links from the Moderation module's Ban and Mute Appeals. BotShade does not yet ship an equivalent form builder or appeals integration.

Side-by-side comparison

Where BotShade and Dyno diverge on command design, AI, moderation, and extensibility.

No-code design (Custom Commands / Builder)

BotShade

Dyno

Command model

DAG editor built on a visual node editor with about 60 node types (slash command, message send, role grant, kick, ban, timeout, external API call, variable set, loop, conditional branch, button, select menu, modal, and more)

GUI form for name, description, and body; the body interpolates variables and calls existing Dyno commands

Branching

Condition nodes for comparison, chance, channel, role, user, permission, and regex, with required child branches (else branch, post-condition branch, and per-condition branches) auto-generated and locked

No language-level branching

Loops, break, continue

Loop, loop body, after-loop, break, continue, and wait nodes

None

Subroutines (Functions)

Custom function definitions, calls, and return nodes with nine argument types (string, number, boolean, user, role, channel, object, array, attachment, plus default values), return values that are void or any type with object sub-properties, and a four-tier scope (global persistent variables, command-scoped, read-only arguments, function-scoped)

None

Error handlers

Error handler node with {Error.message} access, auto-placed at function entry

None

Pre-save validation

Three-stage validation (node-level checks, configuration checks, and function-reference checks), enforced in the editor so the bot does not need to revalidate

Limited explicit pre-save validation UI

Free-plan command limits

Effectively unlimited today

25 Custom Commands, 10 Autoresponders, 3 Forms

AI and generation

BotShade

Dyno

Natural-language command generation

BotShader AI: natural language → command build plan → visual node generation, applied as a reviewable diff with undo

None

AI moderation / LLM judge

Composable via node types and plugins (external API call + conditional branch)

None — AutoMod is fully rule-based

AI-driven iterative editing

Initial release shipped; iterative editing is not yet started

None

Moderation and AutoMod

BotShade

Dyno

AutoMod rule types

Composed from general-purpose condition, regex, and permission nodes — BotShade does not ship a dedicated AutoMod rule catalog

18+ rule types (AllCaps, Bad Words, Newlines, Duplicate Text, Char Count, Emoji Spam, and more)

Action log events

Per-bot structured logs keyed by task name

25+ Discord action log events

Forms and appeals

Not shipped

Forms with short answer, paragraph, multiple choice, and checkbox; Staff Application, Appeals, and Feedback templates wired into the Moderation module

Extensibility

BotShade

Dyno

Plugin marketplace

Marketplace foundation: configuration schema, Settings panel, references constrained to declared config, and state wiring

Around 30 fixed modules; no SDK or third-party marketplace

Persistent variables

Persistent variables catalog with four scopes and atomic read-modify-write

Not exposed at the command layer

Builder depth, not just configuration

Typed functions, structured conditions and loops, persistent variables, an AI that generates commands, and a plugin marketplace turn the dashboard into a small visual programming environment.

Bot ownership and diagnostics

Your own Discord application and token, with per-bot structured logs keyed by task name and date-range filtering for step-level traces.

Mature, rule-rich moderation

18+ AutoMod rule types and 25+ action log events make Dyno the easier pick when moderation breadth is the priority.

Forms with appeals integration

Built-in form builder, Staff Application and Appeals templates, public form URLs, and direct links from the Moderation module's Ban and Mute Appeals.

When to choose BotShade

You want builder depth, typed persistent state, an AI that writes commands, and a marketplace for extending the bot beyond a fixed catalog.

When to choose Dyno

Moderation breadth, AutoMod rule coverage, action log events, and form-driven appeals are the core of what you need, and the fixed module set already fits your workflow.

Coming from Dyno?

Custom Commands and Autoresponders map cleanly onto BotShade nodes, and Dyno's variable interpolation translates into typed persistent variables with variable-aware autocomplete. Moderation rules need a plan: some collapse into conditional branch + regex nodes, others wait on a dedicated AutoMod module. We will help you scope the move.

Talk to support →