Godot Adapt Mobile To Desktop logo

Godot Adapt Mobile To Desktop

Community
thedivergentai
godot-adapt-mobile-to-desktop

Expert patterns for scaling mobile games to desktop including mouse/keyboard controls, increased resolution and graphical fidelity, expanded UI layouts, settings menus, window management, and platform-specific features. Use when creating desktop ports or cross-platform releases. Trigger keywords: mouse_controls, keyboard_shortcuts, resolution_scaling, graphics_settings, fullscreen_toggle, window_modes, Steam_integration, desktop_optimization.

Overview

Publisherthedivergentai
RepositoryGD-Agentic-Skills
Skill namegodot-adapt-mobile-to-desktop
Stars
727
Forks
43
Bundled files
15
LicenseLGPL-3.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 15 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by thedivergentai on GitHub. Read the source before you install it.

Installation

Install the Godot Adapt Mobile To Desktop AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git /tmp/GD-Agentic-Skills
mkdir -p .claude/skills
cp -r /tmp/GD-Agentic-Skills/skills/godot-adapt-mobile-to-desktop .claude/skills/godot-adapt-mobile-to-desktop
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Godot Adapt Mobile To Desktop in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Godot Adapt Mobile To Desktop on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Godot Adapt Mobile To Desktop is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

NEVER Do

  • NEVER keep touch-only controls — Add mouse/keyboard alternatives. Touch controls on desktop feel awkward and limit precision.
  • NEVER lock to mobile resolution — Desktop can handle 1920x1080+ and higher frame rates. Upscale UI, increase render distance.
  • NEVER hide graphics settings — Desktop players expect quality options (resolution, VSync, shadows, anti-aliasing).
  • NEVER use mobile-sized UI — Touch targets (44pt) are too large for mouse. Reduce button/text size by 30-50%.
  • NEVER forget window management — Players expect fullscreen, borderless, maximize, and multi-monitor support.

Available Scripts

MANDATORY: Read the appropriate script before implementing the corresponding pattern.

desktop_input_adapter.gd

MANDATORY first read for input remap — Bridges mobile actions to keyboard/mouse without rewriting gameplay. Emits mouse_look_bridge_requested when FPS capture is needed — pair with mouse_capture_look.

hover_bridge.gd

MANDATORY when UI needs hover — Restores desktop hover/focus affordances mobile never had. Prefer this over ad-hoc mouse_entered dumps.

mouse_capture_look.gd

Captured look via InputEventMouseMotion.relative — use for FPS/orbit when adapter alone is not enough.

dynamic_window_manager.gd

MANDATORY — Windowed / exclusive fullscreen / borderless via DisplayServer.

keybinding_remapper.gd

Runtime InputMap remap + ConfigFile persistence.

cursor_state_manager.gd

Hardware cursor show/hide/combat vs menu states.

uncapped_framerate.gd

VSync / Engine.max_fps unlock for 144Hz+.

resolution_dropdown.gd

Native resolution OptionButton from DisplayServer.screen_get_size.

desktop_ui_scaler.gd

MANDATORY — Shrink thumb-sized mobile Controls for mouse density.

scroll_wheel_zoom.gd

Mouse-wheel zoom replacing pinch.

quit_confirmation.gd

MANDATORYset_auto_accept_quit(false) + save prompt on WM close.

multi_monitor_handling.gd

Launch/place window on the screen under the cursor.


Decision Tree — Input Script Picks

NeedUse
Map touch actions → WASD/mouse without rewriting moversdesktop_input_adapter
Button/Control hover styles & tooltipshover_bridge
Captured mouselook (FPS/3P orbit)mouse_capture_lookMANDATORY when aim/Look requires captured relative motion; adapter get_aim_vector() alone is top-down only
Rebindable keyskeybinding_remapper
Pinch → wheel zoomscroll_wheel_zoom

When desktop_input_adapter emits mouse_look_bridge_requested, attach or enable mouse_capture_look.gd on the player/camera rig — do not stop after InputMap injection.

Port Procedure (ordered)

  1. MANDATORY desktop_input_adapter (+ hover_bridge for UI) so every touch action has a precision equivalent.
  2. desktop_ui_scaler + expanded layouts (hotbar/chat/minimap) — godot-ui-containers for structure.
  3. dynamic_window_manager + multi_monitor_handling + quit_confirmation.
  4. resolution_dropdown + uncapped_framerate + graphics quality ladder (persist ConfigFile).
  5. Deeper OS integration → godot-platform-desktop.

Platform Services Decision Tree (Steam / Discord)

GoalDecision
Ship on Steam with cloud/achievementsAdd GDExtension bridge (e.g. GodotSteam); keep init behind OS.has_feature("steam") / editor-safe stubs. Do not paste fake Steam.* tutorials into gameplay scripts.
Discord Rich Presence onlyPrefer a thin GDExtension/plugin; update presence from an Autoload on scene change — never block _ready on network.
No store integration this milestoneCut — omit Steam/Discord code paths entirely; document as future GDExtension spike.

Deep Recipes

MANDATORY when porting beyond the ordered procedure: read desktop-port-deep.md. Do NOT Load it for a first-pass keyboard/mouse remap.

Testing (before ship)

MANDATORY before declaring the port complete: run desktop-port-testing-checklist.md. Do not inline a partial checklist — use the reference file.

Expert Techniques (short)

  • Optional lightweight launcher via OS.create_process + user://settings.cfg before main pack.
  • Short FPS benchmark → write user://override.cfg quality suggestions.
  • Graphics quality ladder (MSAA, shadow atlas, post-FX) and UI density tables live in desktop-port-deep.md — open when port procedure rows are insufficient.

Reference

Progressive disclosure: open Official Documentation links only when researching a specific API; load Related Skills when routing work to a peer domain — do not preload the whole lattice.

Official Documentation

  • Using InputEvent — Event pipeline for replacing InputEventScreenTouch/ScreenDrag with mouse motion, buttons, and keyboard actions on desktop.
  • Mouse and input coordinates — Viewport vs canvas transforms so mouse aim and hover hit the same UI/game space as former touch targets.
  • Custom mouse cursor — Hardware cursor shapes and hide/show rules for combat vs menus (Input.set_custom_mouse_cursor).
  • Input examples — Practical WASD, mouse-look, and action patterns that map onto mobile virtual-joystick / button actions.
  • Handling quit requestsNOTIFICATION_WM_CLOSE_REQUEST / set_auto_accept_quit(false) so the OS close button can prompt save instead of silent exit.
  • Multiple resolutions — Stretch mode, aspect, and content scale when leaving fixed mobile base resolutions for 1080p–4K and ultrawide.
  • DisplayServer — Window modes, VSync, screen count/size/position, and refresh-rate queries behind fullscreen and multi-monitor ports.
  • Window — Per-window size, position, and mode APIs used with borderless / exclusive fullscreen toggles.
  • InputMap — Runtime remapping of actions to keycodes so PC players can rebind what mobile hard-coded as touch zones.
  • Size and anchors — Anchor/offset contracts when shrinking thumb-sized controls for mouse density without breaking layout.
  • Using Containers — Box/Grid/Margin layout rules for expanded desktop HUDs (hotbars, chat, minimap) vs compact mobile stacks.
  • Feature tagspc / mobile / OS tags for branching input, UI scale, and graphics quality without separate projects.

Related Skills

Prerequisites
  • godot-input-handling — Shared InputEvent buffering, action maps, and device detection before injecting WASD/mouse equivalents for mobile actions.
  • godot-ui-containers — Anchors, containers, and minimum sizes so desktop UI shrink/expand passes keep layout correct across resolutions.
  • godot-platform-mobile — Inventory the mobile lifecycle, touch, and safe-area assumptions you are replacing before desktop window/input paths take over.
Complements
  • godot-platform-desktop — Deeper Windows/macOS/Linux DisplayServer and OS integration once the mobile→desktop control and settings remap is in place.
  • godot-camera-systems — Mouse-look, orbit, and scroll-wheel zoom rigs that replace swipe/pinch camera controls.
  • godot-performance-optimization — Profiling and quality ladders when unlocking FPS, MSAA, shadows, and draw distance for desktop GPUs.
  • godot-save-load-systems — Durable save ownership hooked to window-close confirmation and settings ConfigFile persistence.
  • godot-ui-theming — Theme type variations and hover styles that mobile never showed but desktop players expect on buttons/menus.
  • godot-project-foundations — Display stretch, renderer, and feature-tag project defaults that every desktop port branch depends on.
  • godot-autoload-architecture — Singleton homes for window managers, input adapters, and graphics settings that must outlive scene changes.
Downstream / consumers
  • godot-export-builds — Packaging and CI export presets for Windows/macOS/Linux after input/UI/window gates pass on desktop.
  • godot-adapt-desktop-to-mobile — Inverse lattice when the same codebase must keep or regain touch-first paths after a desktop-first pass.
  • godot-monte-carlo-balancer — Re-tune difficulty when mouse precision and higher FPS invalidate mobile touch timing and aim curves.
Master
  • godot-master — Library router and mirrored module entry for discovering this adapt skill beside sibling domains.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Godot Adapt Mobile To Desktop AI skill do?

Expert patterns for scaling mobile games to desktop including mouse/keyboard controls, increased resolution and graphical fidelity, expanded UI layouts, settings menus, window management, and platform-specific features. Use when creating desktop ports or cross-platform releases. Trigger keywords: mouse_controls, keyboard_shortcuts, resolution_scaling, graphics_settings, fullscreen_toggle, window_modes, Steam_integration, desktop_optimization.

Why use Godot Adapt Mobile To Desktop on TypingMind?

Because you install it once and use it with any model. Godot Adapt Mobile To Desktop is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Godot Adapt Mobile To Desktop in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-adapt-mobile-to-desktop. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Godot Adapt Mobile To Desktop?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Godot Adapt Mobile To Desktop?

As many as you like. As long as a model supports skills, you can use Godot Adapt Mobile To Desktop with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Godot Adapt Mobile To Desktop AI skill free?

Yes. It is published on GitHub by thedivergentai under the LGPL-3.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇