Enhanced Event Popup Usability, Multi-Monitor Support, and Expanded Access for Non-Coders

[toonyman2020]

Issues and Feature Request: Enhanced Event System, Popups, Layout, and Multi-Monitor Support

The current event popup system in Godot feels limited, especially for users working with multi-monitor setups. Right now, the popup doesn’t always open on the monitor where the editor is located, and the window itself cannot be resized or expanded. In modern game development, relying on a single monitor is outdated — most creators work across two or more screens.

Improvements Needed

1. Event Descriptions and Expandable Popups
   Each event should include a clear description explaining what it does. The popup should be fully resizable or expandable and reliably open on the correct monitor.

2. Dedicated Event Tab / Window
   Accessing the list of events could be improved by offering:

a dedicated tab within the Godot interface, or

3. Favorites / Commonly Used List
   A “Favorites” or “Commonly Used” list for quick access would greatly streamline workflow, especially for frequently used events.

4. Simplified Event System for Non-Coders
   This new event-based system looks very promising for non-coders. A simpler, more accessible event system similar to RPG Maker or Game Maker could attract more users who want to create without deep coding knowledge.

Example Implementation:

An event like JUMP with parameters (height, link to running/walking, etc.)

Predefined common game events: walking, running, hitting, actions, talking

Media handling events: AVI, MP4, WAV, MP3, slideshows, comics (CBR), images

Application/window events for creating desktop or mobile apps

Timer events and other utility-based events

With parameters and attributes for each event, this system could be more powerful and flexible than existing engines, offering full control while remaining easy to use.

These changes would make the event system far more intuitive, user-friendly, and better suited for modern multi-monitor environments. It would also make Godot more accessible to non-coders while retaining the power and flexibility that advanced users need.

Thank you for considering this feature. If it’s possible to see even a small demo in action, it would be an amazing step toward making Godot even more approachable — and it would be a fantastic gift for creators this year. Even with the current methods, I still feel a bit lost, but these improvements would help users like me create truly great games.

[Lexian-droid]

I definitely want to implement some options for example pre-made behaviors (as suggested in #5). I was thinking about having this option in the inspector — we’ve already added the ability to set node variables via the inspector, and in that same spot, I plan to have a dropdown for pre-defined behaviors. For example, a Camera3D could have an FPS camera behavior with options like sensitivity, bindings, etc.

Regarding your other issues:

• Multi-monitor popup problems
  This is something I’ll put effort into fixing. I wasn’t aware it behaved incorrectly on multi-monitor setups, but it should be a straightforward fix. I’ll get that sorted.

• Popup window being non-resizable
  This is just a toggle I can change — very easy to fix.

• Need for event descriptions
  I agree this would help a lot. It should be simple to add descriptions for predefined events. For automatically generated events/conditions/actions, it’s trickier since they come from dynamic combinations, and describing every possible variation isn’t feasible. But for standard ones, I can definitely add clear descriptions.

• Dedicated event tab or window
  In the next update, FlowKit will move into the top bar and will no longer be part of the bottom panel. It will take up the whole screen rather than half, which should make navigation and visibility much better.

• Favorites list for quick access
  That’s a good idea. I’ll add this over time.

• Media-handling events
  I might need a bit more detail on what you’re looking for here, but from my understanding, it sounds like you want actions or events for handling media formats. If you generate the nodes, the system should already give you enough control, but feel free to clarify if you had something more specific in mind.

• Application/window events
  Same here — I’d appreciate a bit more clarification, but it seems like this could be covered simply by adding more events/conditions/actions, or by generating them. The system is flexible enough for that, and I can expand it if needed.

• Timer events
  This one is straightforward — these should be easy to add.

• Overall UI/UX improvements of the event system itself
  Take a look at issue Suggestion: Improve the Visual Scripting Interface by Adopting a GDevelop-Style Event Sheet Design #4 to see a preview of the new UI. I’d love to hear your thoughts on it.

Some notes to clarify:

FlowKit is a brand new project. Everything is expandable — you can do anything in it — but each piece needs to be defined separately. That’s why I open-sourced it. If people want to contribute new actions or events, they can. And if something’s missing, just request it. Right now the focus is on getting the foundation in place, so things are limited, but it’ll grow more and more over time. 👍

[Lexian-droid]

Hello! I have an update regarding your issue:

Completed / Added

• Popup window now resizable ✅
• Event descriptions added ✅
• Dedicated event tab/window ✅ (FlowKit has been moved into the top menu)
• Favorites / Quick access ✅ (Implemented as a “Recent” tab that tracks your last used items)
• Overall event system UI/UX overhaul ✅ (Adopted a more GDevelop-style layout — coming in the next update)
• Multi-monitor popup behavior fixed ✅
• Media-handling events ✅ (Added in the latest couple commits)
• Application/window events ✅ (Added in the latest couple commits)
• Timer events ✅ (Added in the latest couple commits)

Legend:
✅ Implemented
🟡 Planned / More info provided

[toonyman2020]

Complete Suggestion: Dual-Mode Event System + Expanded Categories (Simple Mode + Advanced Mode)

I’m really enjoying the direction FlowKit is taking, and I want to propose a more complete vision for a two-method system that supports absolute beginners as well as advanced users. This combines all my earlier points with additional ideas around animation, AI, collisions, custom event creation, and app development.

1. Two Methods: Simple Mode (Method 1) and Advanced Mode (Method 2)
   Method 2

This is the current system you’re building: the powerful, detailed, flexible approach. The new XUI layout fits perfectly here.

Method 1 (New)

This would be a beginner-friendly, ultra-straightforward mode.
Same power, same features — just much simpler to operate.

The idea is to mix:

RPG Maker’s directness (no math, no coding)

GameMaker’s action icons (square buttons with clear labels)

FlowKit’s flexibility

Method 1 should allow total control but through clear actions, simple categories, sliders, toggles, and drop-downs — never formulas or scripting.

Both methods produce the same results, just presented differently.

2. Expanded Examples of How Method 1 Would Work (Including Animation)

When you select an action (Walk, Jump, Attack, Talk, etc.), you automatically get:

Movement settings

Timing settings

Animation settings

Speed options

Limits and ranges

Behavior variations

For example:

Walk

Walk speed

Direction behavior

Loop animation selection

Blend options

Jump

Jump height

Jump speed

Gravity strength

Landing animation

Optional double jump toggle

Talk

Text balloon style

Duration

Voice audio

Auto-advance option

Swim, Fly, Glide, Climb, etc.

Each one comes with its own simple options automatically.

This means Method 1 handles both gameplay AND animation without needing code.

3. New Category: Animation

A dedicated Animation category inside Method 1 that includes:

Play Animation

Loop Animation

Transition to Animation

Blend Between Animations

On Animation End → Trigger X

Flip Sprite / Change Direction

Change Animation Speed

Everything is selected from lists — no programming needed.

4. Custom Action / Custom Script Creation (But Still Simple)

One important feature:
If an action doesn’t exist yet, the user should be able to create it using:

Method 2 (advanced visual logic)
then

Save it as a reusable Method 1 block

So players can build their own simple actions without writing code.

This creates a constantly growing library of actions, both official and user-generated.

There should be a category like:

Custom Actions

Create New Action

Save to Library

Edit Existing Custom Action

This keeps Method 1 expandable forever.

5. Additional Core Categories for Method 1
   Movement

Walk, Run, Jump, Swim, Fly, Dash, Slide, Ladder, Crawl, etc.

Dialogue

Talk, Balloon, Voice Line, NPC Interaction.

Files / Media

Load Image
Load Video
Play MP4
Play MP3/WAV
Save File
Save Screenshot
Write Data
Import Media From PC

Very important for building games AND apps.

Drawing / Creative Tools

For creators who want drawing programs or creative apps:

Enable Drawing

Brush Size

Color Picker

Erase

Save Drawing

Mouse/Tablet Support

Collision

Collision On
Collision Off
Set Hitbox
Detect Overlap
Detect Touch
Detect Click

AI / Enemy Logic

A full simplified AI category:

Pathfinding

Follow Target

Patrol

Chase

Flee

Attack Target

Shoot Projectile

Range Detection

Health system

Aggro system

All done with toggles, sliders, ranges.

Physics

Gravity
Push
Knockback
Bounce
Drag
Slippery ground

Database / Data

Set Value
Increase Value
Decrease Value
Save / Load Data
Inventory

No math required — everything is visual.

Timers

Every timer function, but simplified.

2D, 3D, and Hybrid

Categories based on what the user selected when creating the project — but still allowing mixing 2D + 3D if needed.

6. Application / Desktop / Mobile App Support

FlowKit should support making:

Windows desktop apps

Mac/Linux apps

Mobile apps

In-game computers (mini operating systems)

Small tools and utilities

Creative drawing apps

Media players

UI-heavy applications

So there should be Method 1 actions for:

Open File Dialog

Save File Dialog

Resize Window

Minimize/Maximize

Switch Window Mode

File handling

UI events

This expands FlowKit beyond games into general applications.

7. Media-Handling (Detailed Explanation)

A simple way to:

Load files directly from the user’s computer

Display images in the game or app

Play videos and audio

Save images or data back to the drive

Import media at runtime

Create interactive experiences with user media

All without scripting.

8. Why This Matters

Tools like GDevelop try to simplify things, but still rely on logic blocks and math that overwhelm beginners.
RPG Maker 2003 stayed popular because:

No scripting

No formulas

No code

Everything was already predefined

Everything was named exactly what it is

I’m suggesting a simple mode that gives this same level of comfort, but for:

2D

3D

Apps

Tools

OS-style interfaces

Media tools

Simulations

Creative apps

A universal toolkit anyone can use without coding.

Final Thoughts

FlowKit already has the foundation to become one of the most powerful systems for Godot.
Adding a two-method system — especially Method 1 — would make it accessible to complete beginners without sacrificing depth.

With Method 1 + Method 2 together:

Anyone can build games, apps, utilities, creative tools, hybrid worlds, and even full systems without programming.

FlowKit can become a massive, universal creation tool.

[toonyman2020]

FLOWKIT — THE ART METHOD (Expanded Concept)
01 — The Core Idea

FlowKit gives artists full power to make games and apps without coding, math, or scripting.
You build everything the same way you draw or animate: by choosing actions, behaviors, movements, reactions, and logic — all visual, all plug-and-play.

It’s basically giving an artist the abilities of a full programmer, but with brushes, tools, menus, and options that feel natural.

Think RPG Maker 2003’s simplicity, but for ANY game, combined with the power and freedom that Blender gives artists today — but for gameplay creation.

02 — The Main Systems

Below are the systems broken into clear categories, each with simple visual tools.

A. ACTIONS (Character / Object Behavior)

Everything a character, enemy, prop, or object can do lives here.

Built-in categories

Walk

Run

Jump

Double-jump

Multi Jumps

Swim

Fly

Glide

Dash

Climb

Crawl

Grab / Hold

Push / Pull

Interact

Use item

Attack (multiple types)

Cast spell

Collect

Throw

Build

Farm

Craft

Mine

Chop wood

These appear as visual blocks or dropdowns.

Animation Integration

When you select “Walk,” FlowKit automatically suggests:

Walk animation

Speed

Direction control

Optional variations (slow walk, sneak walk, fast walk)

Select “Jump,” and you get:

Jump animation

Jump height

Jump arc style

Landing animation

Optional double-jump

Every action automatically plugs into the character’s animation sheet.

B. CUSTOM ACTIONS (Create Your Own)

This is where your ultimate freedom comes in.

You click Create New Action, and you get a visual editor like:

Trigger (When does this happen?)

Animation (Which frames?)

Motion (Move how?)

Effects (Particles, sound, screen shake)

Duration

Conditions

What happens after?

This lets artists invent brand-new actions without writing a single line of code.

This new action can then be added to Method 1, so it appears next to Walk/Run/Jump as if it was always built-in.

This is exactly what you were describing — the ability to grow your toolkit forever.

C. LOGIC SYSTEM (Method 2)

Method 2 is the “smart” visual logic editor.
This handles the deeper stuff but stays simple:

If player touches object → do X

If health drops below 20% → play animation

If timer reaches 10 sec → spawn enemy

If item equipped → unlock new ability

If hunger meter low → slow movement

Everything is drag-and-drop, like building blocks.

This is where users can create complex systems that later become new modules for Method 1.

D. ANIMATION SYSTEM (Artwork-Friendly)

This is where artists feel at home:

Tools:

Onion skin

Timeline scrubbing

Frame-by-frame

Bone rigging (optional)

Auto-inbetween

Sprite slicing

Quick import from PNG sheets

Flipbook preview

Motion paths

When an animation is created, it automatically becomes usable in the Action system.

Example:
You animate a “Sword Spin Attack” → instantly appears in Custom Actions.

E. WORLD / ENVIRONMENT SYSTEM

For any game style:

Tiles & Platforms:

Place ground

Place slopes

Place moving platforms

Place ladders

Place liquid zones

Auto-collision toggle

Objects:

Draw or import

Set as solid, bouncy, breakable, climbable, dangerous, collectible, etc.

Interactive Elements:

Switches

Gates

Doors

Pressure plates

Levers

Portals

All plug directly into Method 2 logic.

F. COLLISION SYSTEM

No coding.
Collision is auto-on for anything you drop into the world.

You simply choose:

Solid

Sensor

Trigger

Hazard

Bounce

Platform (one-way jump-through)

Hitboxes can be drawn like shapes or auto-fitted.

G. ENEMY & AI SYSTEM

A full category dedicated to enemies, NPCs, creatures, bosses, etc.

Pre-built AI behaviors

Chase player

Patrol path

Guard area

Flee

Ranged attack

Melee attack

Follow ally

Search last known position

Wander randomly

Idle variants

AI Tools (Easy Mode)

Pick behaviors like stickers and slap them together:

Example:
Enemy =
→ Patrol
→ Chase when player close
→ Attack when in range
→ Return to patrol route if lost sight

No coding. Just stacking behaviors.

Advanced AI (but still visual)

Connect nodes like:

Detect target

Decide threat level

Pick action

Run animation

Deal damage

Retreat

H. GAME STYLES (Templates)

Pick what you're building first:

Platformer

Shooter

RPG

Farming sim

Crafting survival

Open world

Beat ’em up

Puzzle

Metroidvania

Top-down action

Visual novel

App / drawing tool

Utility application

Mobile app templates

Each game style unlocks recommended actions, enemies, and interactions.
But you can mix genres freely.

So yes, you can build a:
“Platformer + farming + crafting + survival + open world + enemy AI + story” game.

I. FARMING, CRAFTING, SURVIVAL SYSTEMS

These become plug-and-play modules.

Farming:

Till soil

Plant seed

Growth time

Water requirement

Harvest animation

Add XP or item drop

Crafting:

Recipe builder

Material drag-and-drop

Output item

Set crafting time

Survival:

Hunger meter

Thirst meter

Temperature

Sleep cycle

Weather damage

Everything stays simple.

J. DRAWING TOOLS (For Creative Apps & Games)

Because you also want the ability to build entire drawing apps:

Brushes

Layers

Canvas resizing

Color picker

Shapes

Undo/redo

Export tools

Custom UI builder

You can literally create a drawing application inside FlowKit.

K. EXPORT SYSTEM

Export to:

Windows

Mac

Linux

Android

iOS

Web

Godot project file

Packaged app

SUMMARY (Short + Clear)

FlowKit becomes:

An artistic, visual, simple creation tool that lets anyone — especially artists — build any game or app without coding.
Actions, animations, logic, AI, world-building, farming, crafting, survival — all simplified and stackable.

You get the freedom to create like a painter or animator, but with the output of a full programming team.

[toonyman2020]

here' some more examples and or suggestions for what i think would be simple straightforward methods of course I would leave that up to the developers to know what is much simpler or easier. the point is to keep it all a simple as possible so one can get straight into just making a game without overthinking it as to what those what and what goes where? this the thing that turns people down with a huge brunout!

ART METHOD — CHARACTER MOVEMENT & INTERACTION FRAMEWORK

1. Camera & World Rotation

The world can rotate around the character, like Mario Galaxy or Animal Crossing, giving a smooth sense of exploration.

Camera can be:

Fixed (2D/side-scroller)

Free (3D exploration)

Planetary (walk around a sphere)

Options to control rotation speed, distance, and follow style (smooth, instant, or lagged for effect).

2. Walk / Run / Movement Options

Movement Blocks (drag-and-drop in the simple method):

Walk / Run / Sprint / Creep / Climb / Swim / Fly

Sub-options:

Direction: Up / Down / Left / Right / Diagonal / Free

Surface interaction: Ground, Water, Tree bark, Slopes, Spikes, Balls

Character response: Stumble, slip, bounce, ripple effect depending on surface

Movement speed: Slow, normal, fast, sprint

Movement style: Smooth, jittery, rigid

Example:

Walk on a tree branch → smaller character height creates a ripple effect.

Walk on spikes → stumble animation triggered.

3. Jump Options

Jump Blocks (drag-and-drop in the simple method):

Basic jump

Double jump / Triple jump / Multi-jump

Jump flow: Smooth, quick, stumble, fall animation

Jump direction: Forward, Up, Diagonal

Landing consequences: Successful, stumble, fail (break leg animation)

Example:

Jump to a floating platform → choose smooth or fast jump

Rare fail chance → triggers stumble or fall sequence

4. Interaction / Talk Blocks

Talk to NPC / Character options:

One “Talk” block opens multiple options:

Ask a question

Make a comment

Create a note

Voice input (optional speech recognition)

Reaction system: NPC reacts based on dialogue:

Positive → friendly gesture

Negative → attack / ignore / leave

Can trigger chained actions: e.g., “Talk → NPC angry → NPC attacks → Player can defend”

5. Object Interactions

Fishing, bug catching, crafting, collecting → each object opens its own interaction block

Example: Fishing Block → select location → select bait → determine success/failure → reward items

Can tie into museum or inventory automatically

Interactions can trigger animations, reactions, or skill XP

6. Relationship & Logic System

Actions & reactions are relatable and chainable:

Walk on spikes → stumble → trigger NPC reaction → influence relationship stats

Talk → positive/negative response → change NPC disposition

Jump fail → animation sequence → environment reacts (break object or hazard triggers)

Allows creating dynamic worlds where characters and player actions are interconnected

7. How This Simplifies Complex Mechanics

Instead of coding every interaction:

Drag a movement / jump / talk / object block

Pick options for:

Direction

Surface / object type

Flow / style / speed

Reaction / consequence

System automatically generates animation, physics, collisions, and AI response.

Key Point:
Everything is hierarchical: one block → opens multiple sub-options. Each sub-option is intuitive, visual, and requires no coding. It’s all about picking actions, flows, and consequences.

[Lexian-droid]

Thanks a lot for taking the time to write all of this out — I can see you put a ton of thought into your ideas, and I genuinely appreciate the enthusiasm. Some of what you described is definitely interesting, but the overall scope goes far beyond what FlowKit is designed to be.

FlowKit is a visual scripting tool. That means it still expects users to understand basic logic and game structure, just without having to write raw code. Its purpose is to make programming easier, not to replace programming entirely or to provide hundreds of pre-built game systems, templates, AI modules, animation presets, app-building tools, or engine-level features.

The system you’re envisioning — a complete no-code engine with automatic animations, built-in RPG/AI/crafting/farming/dialogue systems, a full app toolkit, pre-designed UI actions, export modules, and user-generated action libraries — is realistically the scope of multiple entire products, each with full-time development teams behind them. It’s not something a single plugin can take on, and it’s not something FlowKit was ever intended to become.

I’m keeping FlowKit focused on what it’s good at:
a clean, flexible visual-logic workflow that helps developers build their own systems instead of having the tool build everything for them.

So while I really appreciate the passion behind your suggestions, I won’t be steering FlowKit in that direction — it simply isn’t feasible, and it would turn the project into something completely different from what it’s meant to be.

I hope you can understand, and please feel free to keep suggesting smaller, focused improvements. Those are much more realistic to evaluate and integrate.

[toonyman2020]

It is feasible. GameMaker and RPG Maker already proved the concept years ago — and Godot pushes that idea even further. With Godot’s flexibility and a community-driven approach, something like FlowKit could easily become the next evolution of that whole philosophy. The idea isn’t far-fetched at all. It’s already within reach.

The truth is, the only thing that ever made animation or game dev feel “impossible” was the tools — not the creators, not the ideas. The tools were outdated, clunky, overcomplicated, and built in ways that crush momentum. That’s what drains the joy out of creating and why so many people quit. We could’ve had a world full of amazing games and animation by now if the tools didn’t keep putting walls in front of everyone.

AI proved that. The moment AI arrived, it became clear the real barrier wasn’t ability — it was the system. Everything was overengineered for no reason. We’ve been stuck repeating the same cycle, hitting the same bottlenecks, using workflows that slow everyone down. That’s the problem that needs solving.

Now imagine a tool where that complexity is gone. Imagine game development feeling like play again — not punishment. Imagine creating because it’s fun, not because you spent weeks debugging something as basic as a walk cycle.

That’s what FlowKit could become:
the first true sandbox game engine ever made.
An engine built for one purpose — letting you make games.

No gatekeeping.
No walls.
No five-year learning curve.

A simple, readable language anyone can understand.
A modular system open enough that even a beginner could make their own plugin.

GameMaker hinted at this, but didn’t fully reach it — it works, but you still end up relying on scripts and it doesn’t have that spark. RPG Maker is the friendliest tool around, but it’s limited by its own simplicity and imagination. There’s never been an engine that’s both easy and powerful — accessible and limitless — built around pure creativity first.

But the idea exists.
The foundation exists.
The potential is already here.

It isn’t impossible at all.

It just needs someone willing to take that first step into new territory. Without something like FlowKit, people will keep getting overwhelmed, burning out, and quitting their dream projects before they ever get off the ground. It shouldn’t be like that.

And we can start small — one tiny sample to prove the concept. A basic Mario-style platformer with only the essentials:

Core Sample Features (~20 blocks or less):

Walking

Running

Jumping

Swimming

Power-ups (Grow, Shrink, Fire/Shoot, Invincibility)

Enemies

Pipe warps

Flagpole slide

Entering a small castle

Bowser-style bridge/key moment

Simple character text (Toad/Peach line)

Timer

Score

Lives

Music

Sound effects

All of this can fit under 20 clean, intuitive blocks if the system is built right — and it would be the perfect proof of what FlowKit can really do. So when someone says this isn’t feasible, it actually supports the entire argument: limitations are what kill imagination.

And honestly, the gaming industry desperately needs more creativity again. We’re drowning in sameness because the barrier to entry keeps going up instead of down.

As an artist, I want to create nonstop — that’s the whole point. Tools should empower that, not choke it. FlowKit isn’t just possible — it’s the kind of thing the industry has been needing for years.

And let’s be real: if anyone ever wished they could make art easily, AI finally gave them that chance. You don’t need years of school to bring your vision to life. But even AI has its own limitations, its own chains — locked behind corporations, overpriced hardware, and constant restrictions.

So if there’s ever been a call for something better than AI, something more accessible, more powerful, more creative — it would be a tool like this. A truly advanced, open, intuitive system that anyone can have.

That’s exactly where FlowKit could come in. Best of all you don't have to mess with what you have now just create it on a separate category within flowkit you can even call it flowkit sandbox or whatever.

[Lexian-droid]

Does this sound more like what you want?
https://youtu.be/DVyj4ggHPWw

[toonyman2020]

Does this sound more like what you want? https://youtu.be/DVyj4ggHPWw

Not quite, but should be as powerful without complications. What I’m looking for is closer to this one: https://youtu.be/V5DBWm8-6lA?si=Y7nlj3LA5qDyzgcx

The whole idea is super simple. If your character needs to walk, you grab the walk block or event, set a key, button, or whatever control you want, choose the animation speed, choose the movement speed — done. No overthinking, no digging into code, nothing confusing. Everything is already spelled out.

And when you start combining these blocks, that’s when you get different results or effects. Like mixing the jump block with the walk block, or adding something else on top of it. It’s all about stacking behaviors.

I might just make a diagram to show what I mean.

[toonyman2020]

Here I hope you can understand or the idea of my spagetting mess here of what i was going for it suppose to be simple once you get the idea.

[Lexian-droid]

I get what you’re aiming for, and I understand the direction you have in mind, but I’m not able to build something on that scale. FlowKit is designed specifically as a Godot addon that brings visual scripting into your projects. It’s meant to mirror the event-based style you see in Construct, Clickteam, or GDevelop — not to serve as a full game engine. I actually considered building a standalone engine at one point, but choosing to make FlowKit an addon solved the problems I wanted to address, and it felt like something people might genuinely find useful. That’s why I released it.

If you’re still set on creating a full engine like the one you described, you’d need to take that on yourself or work with someone who has the scope and experience for it. It’s simply beyond what I’m capable of doing right now.