“The experience supports Markdown style input and files for users who prefer to work directly with the lightweight markup language,” explains Dave Grochocki, principal product manager lead for Microsoft’s Windows inbox apps. “You can switch between formatted Markdown and Markdown syntax views in the view menu or by selecting the toggle button in the status bar at the bottom of the window.”
With Stem Splitter, you can now extract stems for guitar and piano, for a total of six stems.
2000-2001: Miguel de Icaza and others start the GNOME desktop environment project for Linux. GNOME 1.2 is released with issues, including shipping with five different clock applications. This experience informs de Icaza's later development philosophies, specifically the idea of avoiding unnecessary options and complexity.
Pre-Xogot Development (Undated, implied years prior to GodotCon 2024): Miguel de Icaza works on Swift language bindings for Godot Engine as a GD Extension. He also works with another fellow named Nat Friedman to create Mono, an open-source .NET implementation, which Unity Engine is later built around.
Prior to GodotCon 2024: Initial work is done on a "libgodot" approach for embedding Godot within other applications. Miguel de Icaza expresses his dream of this functionality to Juan.
GodotCon 2024: Miguel de Icaza gives a talk detailing the development of Xogot, a project to bring Godot Engine to the iPad. He explains the challenges of adapting Godot's desktop-centric UI for a touch interface and the approach of using Swift UI as a separate UI layer communicating with the Godot editor core (the source of truth). He highlights the successful virtualization of the Godot editor and game running simultaneously by manipulating a variable pointing to the application's state. He also mentions the limitations of the platform, such as only supporting GDScript and not supporting third-party C++ GD Extensions due to Apple's security policies. The goal is to achieve an Apple Design Award. The beta test program is announced, requiring a TestFlight ID or Apple ID and information on needed GD Extensions.
November 13, 2024: Users begin discussing Git issues related to dubious ownership. Joseph.hill confirms receipt of requests for beta access.
November 14, 2024: Djemergency reports a visual bug with export variables not displaying correctly (e.g., "walkingSpeed" appearing as "walkingSpeed" instead of "Walking Speed").
November 15, 2024: Hyouuu. requests beta access. Miguel de Icaza confirms he will process requests later.
November 16, 2024: Miguel de Icaza announces a new batch of beta testers has been invited. Several users, including russellup.art, trueh_91782, hilidice, brunotor, bpgam3z, and silent_rkgk, confirm joining the server and express excitement. Discussions about server administration and behavior occur.
November 17, 2024: Discussions about visual shaders and the potential to replace the visual editor dock occur. Detox0236 requests the status bar be hidden for fullscreen testing. Wolfybl is noted for being impatient about getting beta access. Joseph.hill sends out a tranche of invites. Miguel de Icaza notes they haven't done any rejections for the beta. Discussion about the TestFlight beta duration (90 days). Users confirm projects can be created on the desktop Godot version and transferred to the Xogot folder on iPad.
November 18, 2024: Miguel de Icaza comments on viewport issues.
November 19, 2024: Clancey asks detox0236 about having multiple games in their GitHub repo. Detox0236 confirms. Miguel de Icaza notes an issue with something triggering a stop. Ciidi inquires if an invalid method after variables in a script could cause this and mentions random green highlighting in the script editor. A link to a GitHub repository of "godot-ipad-demos" by celyk is shared.
November 20, 2024: Endritdev expresses appreciation for the "Infinite Canvas" demo. Detox0236 clarifies their request for a hidden status bar is for running the scene embedded, but Miguel de Icaza initially thought they meant on its own scene. Miguel de Icaza considers running the scene in the same window for more control over fullscreen.
November 22, 2024: Miguel de Icaza reports that a Skeleton3D issue uncovered multiple issues and he is close to fixing them. Mascaz offers to continue testing once fixes are out.
November 23, 2024: Detox0236 notes that Xogot pauses music playback. Andrekling asks about the code window adjusting in vertical mode. Users discuss the lack of support for C++ GD Extensions. Paraxikology confirms their custom extensions are not public. Firesonwires notes that C# extensions likely won't be possible either due to JIT.
November 24, 2024: Endritdev mentions the Windows development of their personal project. Miguel de Icaza confirms that C++ GD Extensions and C# extensions won't be possible for a while but has an idea for native ones.
November 25, 2024: Users comment positively on the visual appearance of Xogot. Miguel de Icaza advises kindness in discussions. Wolfybl and thedarkwaterbun confirm knowing each other from another server. Vernacular mentions their Apple devices sharing data. Clancey suggests asking Apple for an exception for Xogot regarding data sharing. Vernacular humorously dismisses the idea due to homework.
November 26, 2024: Vernacular and Clancey discuss Apple device data sharing. Miguel de Icaza reacts with a smiley face.
November 27, 2024: Verxion suggests using Xogot for homework. Joseph.hill sends out another wave of invites. Detox0236 comments on the user data sharing.
November 28, 2024: Endritdev asks if game building/exporting is possible or will be included. Miguel de Icaza confirms James is working on an "export game" feature in developer mode. Victororange_ observes that invites seem to be sent in batches in the mornings.
November 29, 2024: Joseph.hill sends out a fresh batch of invites. Paraxikology asks if Xogot will be locked to Godot 4.3. Josephsmth relays that Miguel de Icaza's talk indicated relatively easy updates to new Godot versions, including the upcoming 4.4 with Metal support.
November 30, 2024: Endritdev highlights the need for visual tools for curves, color ramps, and gradients, noting that standard Godot has these.
December 1, 2024: Miguel de Icaza anticipates finding many touch scenarios needing improvement and wants a catalog of these. Josephistheone asks if Xogot is a one-time use thing (likely referring to the TestFlight duration). A link to the V-Sekai/xr-grid GitHub repository is shared.
December 5, 2024: Miguel de Icaza fixes a bug related to binding objects from different "domains" (editor vs. game). Snowminx shares a GIF of the bug.
December 12, 2024: Discussion about a pencil drawing feature in VR or "pancake" mode. Detox0236 had trouble with procedurally generating sound.
December 16, 2024: Discussion about Xogot running on iPhones, noting it launches but isn't particularly useful yet.
December 17, 2024: Users react positively to a visual update shared by Miguel de Icaza.
December 18, 2024: Miguel de Icaza mentions papercuts but is excited about the visual update. A screen recording of the UI is shared. Discussion about the shader editor Shade, with some users preferring text-based editing or noting missing features.
December 19, 2024: Le.vibs and yulrun discuss the Shade app. Yulrun asks about Godot export formats. Sethdrebitko mentions a custom Godot exporter for Shade may exist.
December 25, 2024: Joseph.hill fixes a DNS issue preventing access to the docs page. Liannuha confirms access is restored.
December 26, 2024: Niugames asks about using spaces instead of tabs. Djemergency reports that the debugger in Xogot is not providing the same error information as the desktop version.
January 1, 2025: Djemergency plans to add reported bugs to Git.
January 5, 2025: Snowminx crashes their project due to an issue with accessing an enum from an autoload script, but then fixes it.
January 8, 2025: Saintvulture finds that a reverted project still has the same errors but works, indicating the issue is on their end. Miguel de Icaza observes that Godot seems to accept and report invalid states, which are easy to create, particularly in animations.
February 4, 2025: Joseph.hill suggests a UI approach for renaming nodes. Miguel de Icaza notes the issue with invalid names in a popup. Discussion about performance on different Apple Silicon chips (M machines, M4 Airs).
February 6, 2025: Miroslav_40962 adds a Paint feature to the TileSet editor and plans to implement native editors for navigation, physics, and occlusion layers. Joseph.hill discusses building for Windows from a Mac, noting it can be done without a VM. Yulrun confirms wanting to compile their desktop game for Windows.
February 8, 2025: Miguel de Icaza explains how to use add-ons by enabling the developer menu and accessing the asset store.
February 9, 2025: Kurama0 asks about the average time to get accepted into the TestFlight program. Joseph.hill sends out a batch of invites.
February 18, 2025: Yulrun highlights Xogot on their "Tools & Software" page to support the project.
February 20, 2025: Miguel de Icaza discusses UI ideas for notifications and confirmation. Andrekling asks about missing icon indicators for nodes in groups. Miguel de Icaza confirms he intentionally removed them due to too many indicators and asks for usage scenarios to find alternative solutions.
February 22, 2025: Miguel de Icaza mentions the TestFlight/beta process.
February 23, 2025: .definitelyanormalperson asks if extensions work and how to install them. Miguel de Icaza confirms GDScript extensions work by placing code in the addons directory and enabling them in project settings.
March 2, 2025: Miguel de Icaza discusses Feature Tags as a way to control code based on context (debug vs. published, wasm vs. iOS). He notes the UI challenge for implementing this on iPad.
March 3, 2025: Shinkamui asks about enabling Vision Pro as a TestFlight target or providing an IPA. Miguel de Icaza doubts it will work well but thought it might have been left enabled. Joseph.hill also thought so.
March 6, 2025: Andrekling asks if a recent change improves performance. Miguel de Icaza says he forced a size for now but needs more plumbing for a full feature. He notes that standard Godot has more features for running in a window than just basic embedding.
March 7, 2025: Miguel de Icaza implements a rescan feature. He shares a link to the mlx GitHub repository (an array framework for Apple silicon) and expresses enthusiasm. He discusses a 0% APR payment plan influencing a purchase and issues with triggering external display functionality.
March 17, 2025: Andrekling asks if the Xogot team would consider joining the Godot development fund. Snowminx suggests Apple funding it like Microsoft funds the C# part. Miguel de Icaza notes that his past efforts to get C# funding weren't enough and emphasizes the need for a sustainable offering.
March 27, 2025: Miguel de Icaza confirms James is working on implementing a feature requested by Snowminx related to testing things while out. He mentions small steps towards iPhone support and a large refactoring landing this week to help. He notes that a full experience is needed for iPhone reviews.
March 29, 2025: Djemergency shares a small teaser. Snowminx asks if local LLMs will be supported. Djemergency considers adding support. Miguel de Icaza clarifies that native GDExtensions are not supported on iOS due to Apple's restrictions on third-party code loading, but popular ones might be bundled.
April 1, 2025: Alej7456 starts a thread. A link and image related to a Metal Rendering Backend for Godot are shared.
April 3, 2025: Discussion about a price shown in TestFlight, confirmed by Miguel de Icaza to be a dummy price.
April 4, 2025: Wojciech.p and drone_logic inquire about the actual cost of Xogot. Snowminx suggests the answer is they don't know yet.
April 7, 2025: Miguel de Icaza announces Release 2047, which includes a feature where docks added by extensions surface on a dedicated tab in the inspector.
April 13, 2025: Miguel de Icaza investigates issues with fonts leaking memory and allocating excessive RAM, particularly when switching from light to dark mode. He prototypes ideas for an iPhone shell.
April 16, 2025: Miguel de Icaza notes that abstracting the shell into functional units has helped with faster prototyping and made developing a custom iPhone shell simpler.
April 29, 2025: Thesylex reports a failing TestFlight invitation. Miguel de Icaza has not seen this issue before.
April 30, 2025: Scstefan questions a paywall message seen in the app. Joseph.hill confirms they have been testing the paywall for a few weeks and that purchases in TestFlight do not actually charge.
May 2, 2025: Miguel de Icaza announces Build 2198, which completes the rewriting of main shell tasks, including the TileSet and TileMapLayer editors joining other rewritten editors.
May 9, 2025: Miguel de Icaza considers adding more keyboard shortcuts and will check standard Godot's approach. He notes command-tab is taken by the OS but will find alternatives like Control+tab for editor tabs.
May 10, 2025: Moricq clarifies an issue where Xogot doesn't show the actual color in the UI like standard Godot does. Miguel de Icaza confirms he will add ColorRect in the short term and think about a long-term solution.
May 11, 2025: Maliciousmunch expresses concern about the potential pricing of Xogot, hoping it remains accessible. R10k_og discusses the team's goals regarding monetization and accessibility. Bennlloyd reacts with a laughing emoji. Andrekling humorously warns against retroactive fees. Jupiner_ expresses excitement after seeing Xogot at PAX and suggests a "Xogot" game jam.
May 12, 2025: Phoenixhimself inquires about a 3D terrain editor, clarifying they meant 3D, not the 2D editor Miroslav_40962 had been working on.
May 13, 2025: Discussion about visual shaders. Pza_art confirms they can type code for shaders but wanted to use the visual editor. Miguel de Icaza mentions having code for visual shader support but wanted to "iPadize" the UI shell. He then surprisingly discovers he had already written the support for it and provides instructions and a screenshot.
May 14, 2025: Miguel de Icaza reacts positively to a visual update. Discussion about font alignment and weights for different sizes. Reno6693 suggests new icons might be needed.
May 15, 2025: Joseph.hill files an issue (#1353). Miguel de Icaza asks about the property being animated to reproduce a potential bug. Reno6693 reports that Xogot doesn't seem to edit Tab Stop values in Label nodes. Maliciousmunch reports that a "waterfall project" using the web Godot editor for visual shaders and Xogot for the rest is running nicely.
May 16, 2025: Panampace shares a prototype created in Xogot. Detox0236 finds that basic compute shader examples work, correcting a previous assumption. Lithalean suggests AppleTV as a target for running .pck files with a controller. Miguel de Icaza shares an image related to an upcoming feature.
May 17, 2025: Andrekling and Miguel de Icaza discuss creating a dedicated channel for iPhone beta feedback or bugs. Miguel de Icaza creates an #iphone-bugs channel. A log entry indicates that Build 2203 fixed window embedding from Godot, enabling the Visual Shader Editor's "Add Node" button (#1346).
May 18, 2025: Panampace asks Miguel de Icaza about the future vision for Xogot – whether it's primarily for existing Godot developers on iPad or for attracting new developers as a standalone offering. They highlight its potential as a unique and feature-rich app on the App Store.
May 20, 2025: Miguel de Icaza provides an update on a fix for the Label node Tab Stop issue. Madumbarra reports issues with TileSets, TileMaps, and viewing textures in the TileSet menu. .shaunh reports a visual bug with "Unlock XogotPro" message when it's already unlocked and a crashing bug when closing the first script tab when multiple are open.
May 21, 2025: Detox0236 shares an experiment using the Apple Pencil. Miguel de Icaza praises it.
May 22, 2025: Miguel de Icaza finds and tests a fix for a bug. Detox0236 confirms the issue is resolved and the "buy" messages in TestFlight are indeed not charging. Silent_rkgk suggests sponsoring game jams with free access or licenses. Joseph.hill agrees this is possible now.
May 24, 2025: Detox0236 shares an experiment using the gyroscope. Miguel de Icaza asks if a shader was used, and detox0236 confirms it was.
May 27, 2025: R10k_og notes that an undo function that previously didn't work for the tree now does. Miguel de Icaza discusses the design challenge of adding more buttons to the cramped iPhone UI.
Cast of Characters
Miguel de Icaza: The central figure behind the Xogot project. A well-known software developer, co-creator of GNOME and Mono, and contributor to the .NET stack. He is leading the effort to bring Godot Engine to the iPad using Swift UI and a libgodot approach. He is actively involved in the Xogot beta testing community, fixing bugs, discussing features, and interacting with users.
Joseph.hill: A member of the Xogot team, actively involved in managing the TestFlight beta program, sending out invites, and addressing technical issues like DNS problems. He also participates in feature discussions.
James: A member of the Xogot team, mentioned by Miguel de Icaza as working on the "export game" functionality.
Nat Friedman: Co-creator of Mono with Miguel de Icaza.
Juan: Mentioned by Miguel de Icaza as someone he discussed the "libgodot" dream with years prior. Likely refers to a prominent figure within the Godot Engine development team.
Detox0236: An active participant in the Xogot beta community, providing feedback on features, reporting bugs (including music pausing and sound generation issues), and engaging in discussions. They also create and share small experimental projects using Xogot.
Silent_rkgk: An enthusiastic beta tester and "hypeman" for Xogot. They provide feedback, encourage other users, and suggest ideas like sponsoring game jams.
Endritdev: A beta tester who provides feedback, asks questions about features like game building, and highlights the need for visual editing tools.
Snowminx: A beta tester who reports bugs, suggests features (like bottom-tabs getting bold), and participates in discussions.
Djemergency: A beta tester who reports bugs (visual issues, debugger information) and plans to add them to Git. They also share teasers of their work and consider adding LLM support.
Yulrun: A beta tester who discusses hardware, reports on Xogot's performance, and publicly supports the project by highlighting it on their website. They also inquire about Godot export formats and the Shade app.
Saintvulture: A beta tester who investigates and reports on bugs they encounter.
Mascaz: A beta tester who provides feedback on specific issues like the Skeleton3D bug and offers to continue testing.
Ciidi: A beta tester who reports on script editor behavior and potential bugs.
Paraxikology: A beta tester who inquires about support for C++ GD Extensions and the targeted Godot version.
Vernacular: A beta tester who participates in discussions about Apple device data sharing.
Verxion: A beta tester who participates in discussions.
Josephistheone: A new beta tester who asks a clarifying question about the beta program's usage.
Liannuha: A beta tester who confirms access to the docs page after a fix.
Niugames: A beta tester who asks about text editing preferences (spaces vs. tabs).
Miroslav_40962: A beta tester and likely contributor working on implementing native editors for TileSet painting, navigation, physics, and occlusion layers.
Firesonwires: A beta tester who discusses the limitations regarding C# extensions.
Wojciech.p: A beta tester who inquires about the cost of Xogot.
Drone_logic: A beta tester who follows the discussion about Xogot's cost.
Kurama0: A beta tester who inquires about the acceptance time for the TestFlight program and humorously offers to "break it even further" after a fix.
Andrekling: A beta tester who provides feedback on UI layout and missing indicators, asks about performance, and suggests the team join the Godot development fund.
.definitelyanormalperson: A beta tester who asks about extensions.
Shinkamui: A beta tester who inquires about Vision Pro support.
Penwick: A new beta tester asking questions.
Thesylex: A beta tester reporting an issue with their TestFlight invitation.
Scstefan: A beta tester who notices and questions the paywall test in TestFlight.
Maliciousmunch: A beta tester who expresses concerns about the pricing of Xogot and reports on running a project.
R10k_og: A beta tester who discusses monetization goals and reports on the undo functionality.
Bennlloyd: A beta tester who reacts with a laughing emoji.
Jupiner_: An indie Godot developer who saw Xogot at PAX and expresses excitement.
Phoenixhimself: A beta tester who inquires about a 3D terrain editor.
Lithalean: A beta tester who explains the "libgodot" concept and suggests AppleTV support.
Moricq: A beta tester who clarifies a UI issue regarding color display.
Panampace: A beta tester who shares a prototype and asks about the long-term vision for Xogot.
Alej7456: A user who starts a thread about the Metal Rendering Backend.
Hyouuu.: A user requesting beta access.
Forcedev: A user who humorously asks to call it "cso-got".
Josephsmth: A user who comments on Miguel de Icaza's talk references and explains the beta invite process.
XXiainxx: A user who makes a Canadian-themed joke about the name "Xogot".
Wolfybl: A beta tester known for being impatient about getting access.
Trueh_91782: A user who joined the server.
Hilidice: A user who joined the server.
Brunotor: A user who joined the server.
Bpgam3z: A user who joined the server and expresses excitement.
Gameinatrixc0ri: A user waiting to test and expressing excitement.
Thedarkwaterbun: A user who asks about server administration and confirms knowing wolfy from another server.
White.car.dev: A user who participates in discussions about potential issues.
Bisbille0934: A new user asking questions about the beta and if silent_rkgk is a developer.
Clancey: A user who asks about project organization on GitHub and discusses Apple data sharing.
.Shaunh: A beta tester who reports visual and crashing bugs.
Detox0236 (celykdev.bsky.social): Also identified by their Bluesky handle, used for sharing experimental projects.
Pza_art: A beta tester who is learning shaders and wanted to use the visual editor.
Reno6693: A beta tester who reports an issue with editing Tab Stop values and discusses UI design.
Study Guide
Quiz
What is the primary purpose of the KenneyNL/Starter-Kit-FPS on GitHub?
What type of license governs the use of the software in the KenneyNL/Starter-Kit-FPS?
What are some of the features included in the KenneyNL/Starter-Kit-FPS?
What is the main focus of the godotengine/godot-docs GitHub repository?
Under what license are the files in the classes/ folder of the godot-docs repository distributed?
What is Xogot, and what platform is it primarily being developed for?
Why did Miguel de Icaza decide to rewrite the UI for Xogot using Swift UI instead of using the existing Godot editor UI directly?
What are two major limitations of Xogot mentioned regarding language support and extensions?
According to the Xogot Discord discussions, what are some of the editor components that have been rewritten using SwiftUI?
What input method considerations are highlighted as different between a traditional desktop Godot setup and using Godot on an iPad with Xogot?
Quiz Answer Key
The primary purpose is to provide a basic template for a first-person shooter game within the Godot 4.3 game engine. It includes core features for building an FPS.
The software in the KenneyNL/Starter-Kit-FPS is governed by the MIT License.
Features include a character controller, weapons and weapon switching, enemies, and CC0 licensed sprites and 3D models.
The godotengine/godot-docs repository contains the official documentation for the Godot Engine.
The files in the classes/ folder are distributed under the MIT license, with the same authors as the main Godot source repository.
Xogot is a project to bring the Godot game engine editor to the iPad, built using Swift UI.
He found the existing Godot editor UI not well-suited for the iPad's touch-based interface and smaller screen, preferring the declarative nature and data-binding of Swift UI.
Xogot currently only supports GDScript, and third-party C++ GD extensions are not supported due to Apple's security requirements for loading dynamic libraries.
Rewritten components include the TileSet and TileMapLayer editors, SpriteAnimationEditor, Animation editor, Debugger, and Output.
Desktop Godot heavily relies on mouse and keyboard shortcuts, while Xogot on iPad requires consideration for touch gestures, larger tapable regions (44 points), and the potential lack of a physical keyboard or mouse.
Essay Format Questions
Compare and contrast the goals and licensing models of the KenneyNL/Starter-Kit-FPS and the core Godot Engine documentation. How do these different repositories contribute to the broader Godot ecosystem?
Analyze the technical challenges and solutions discussed by Miguel de Icaza in bringing the Godot editor to the iPad as Xogot. Specifically, discuss the concept of virtualizing the Godot core and the implications of using Swift UI for the user interface.
Evaluate the limitations of Xogot (language support, extensions) in the context of its target platform (iPad) and distribution method (App Store). How do these limitations impact the types of projects that can be developed using Xogot compared to the desktop Godot editor?
Discuss the ongoing development and testing process of Xogot as revealed in the Discord excerpts. What types of bugs and features are being discussed, and what does this suggest about the current state and future direction of the project?
Consider the potential impact of Xogot on the Godot community and game development in general. How might making a powerful game engine editor accessible on a mobile platform like the iPad change how people learn, prototype, and develop games?
Glossary of Key Terms
Godot Engine: A free and open-source, cross-platform game engine used to create 2D and 3D video games.
Xogot: A project by Miguel de Icaza to port and adapt the Godot Engine editor for use on the iPad, primarily utilizing Swift UI for the user interface.
Swift UI: A declarative UI framework developed by Apple for building apps across all Apple platforms.
GDScript: A lightweight, dynamically typed scripting language designed specifically for the Godot Engine.
GD Extension: A system in Godot that allows for extending the engine's capabilities using compiled languages like C++ or other scripting languages.
MIT License: A permissive free software license that allows for wide use, modification, and distribution with minimal restrictions, primarily requiring retention of the copyright and license notices.
CC0 License: A public domain dedication, meaning the author waives all copyright and related rights, allowing anyone to use the work without restriction.
TestFlight: A beta testing service by Apple that allows developers to invite users to test their iOS, iPadOS, tvOS, and watchOS apps.
Libgodot: The core library of the Godot Engine, which Xogot utilizes as the underlying engine functionality.
Swift: Apple's powerful and intuitive programming language for building apps for Apple platforms.
Static Variable: A variable in programming that retains its value throughout the life of the program, as opposed to local variables that are created and destroyed within a function or block. Virtualizing these was a challenge in Xogot's development.
Singleton: A design pattern in which a class has only one instance and provides a global point of access to it. Godot uses singletons, which presented challenges for virtualizing the engine state in Xogot.
Inspector: A panel in the Godot editor that allows users to view and edit the properties of selected nodes and resources.
Scene Tree: The hierarchical structure of nodes that compose a scene in Godot.
Nodes: The basic building blocks of a Godot project, representing elements like characters, objects, and environments.
Assets: The creative content used in a game, such as 2D sprites, 3D models, sound effects, and music.
Character Controller: A component or script that handles player movement and interaction within a game environment.
Rendering Backend: The part of a game engine responsible for drawing graphics to the screen. Metal is Apple's low-level graphics API and a potential rendering backend for Godot on Apple devices.
TileSet: A collection of tiles used to create 2D levels and environments in Godot.
TileMap: A node in Godot used to draw levels using a TileSet, allowing for efficient placement and manipulation of tiles.
Shader: A program that runs on the graphics processing unit (GPU) to determine how objects are rendered. Godot supports both text-based and visual shaders.
Visual Shader: A node-based editor in Godot for creating shaders without writing code.
Autoload: A feature in Godot that allows scripts or scenes to be automatically loaded at the start of the game and accessed globally as singletons.
Feature Tags: In Godot, a mechanism to include or exclude code or assets based on specific tags, useful for platform-specific development or debugging.
Vector math: Mathematical operations involving vectors, commonly used in game development for movement, direction, and position.
Transforms: Mathematical structures used in game development to represent the position, rotation, and scale of objects in 2D or 3D space.
Collision Shapes: Geometric shapes attached to nodes in Godot to define their physical boundaries for collision detection.
Briefing Doc
This briefing document provides a review of the main themes and important ideas presented in the provided sources, focusing on the Godot Engine and the Xogot project (Godot on iPad).
Source Overview:
The sources include:
Excerpts from the GitHub repository for a Godot FPS Starter Kit by KenneyNL, providing an example of a Godot project.
Excerpts from the GitHub repository for the official Godot Engine documentation, highlighting its licensing and scope.
Excerpts from the Godot Engine official documentation itself (specifically for the 4.4 branch), detailing the engine's features, architecture, development practices, and export options.
Excerpts from a GodotCon 2024 talk by Miguel de Icaza on "Using SwiftGodot: Godot on iPad," outlining the challenges and approaches to porting Godot to the iPad using Swift UI.
Excerpts from the Xogot Discord server text channels (announcements, bugs, features, general, iphone-bugs, projects), providing real-time insights into the development, testing, user feedback, and challenges of the Xogot project.
Key Themes and Important Ideas:
1. Godot Engine: Open-Source, Feature-Rich, and Community-Driven
Open-Source and Licensing: The Godot Engine is clearly presented as an open-source project, primarily under the MIT license. This is evident in the GitHub repositories for both the documentation and the FPS starter kit, as well as explicitly stated in the Godot documentation itself ("View license"). The MIT license allows for significant freedom in using, modifying, and distributing the software, including for commercial purposes. The assets included in the KenneyNL FPS starter kit are explicitly mentioned as CC0 licensed, meaning they are in the public domain.
Comprehensive Documentation: The extensive list of topics covered in the Godot documentation (2D/3D graphics, physics, scripting, audio, networking, etc.) highlights the engine's breadth of features and the detailed resources available to developers. The documentation repository is a significant part of the Godot ecosystem.
Multi-Platform Support: Godot is designed to be multi-platform, supporting various operating systems for both the editor and exported projects (Windows, macOS, Linux, mobile, web, etc.). The documentation details export options for different platforms.
Scripting and Extendability: Godot supports multiple programming languages, including its own GDScript and C#. The concept of GD Extensions is mentioned as a way to extend the engine's functionality, particularly with languages like Swift and C++.
Development Practices: The documentation touches on best practices for project organization, using different node types, handling data, and optimizing performance. It also mentions the warning system in GDScript and how to use tool mode (@tool) for running code in the editor.
Versioning and Release Policy: The documentation outlines Godot's versioning and release policy, including guidance on which version to use for new projects and upgrading existing ones. The provided sources reference Godot 4.3 and the upcoming 4.4, which is expected to include Metal support.
2. Xogot: Bringing Godot to the iPad with Swift UI
The Challenge of Porting to iPad: Miguel de Icaza's talk and the Discord conversations highlight the significant challenges of bringing a desktop-focused game engine like Godot to the iPad. Key issues include:
Input Differences: Godot is designed for mouse and keyboard, while the iPad relies on touch and optional accessories like the Apple Pencil and external keyboards. This requires a significant redesign of the UI and interaction methods.
Touch Target Size: Apple's requirement for a minimum tapable region (44 points, roughly 150 pixels) necessitates larger UI elements than typically found in the desktop Godot editor.
Expected Gestures: iPad users expect certain gestures to be available, which need to be implemented.
Performance Considerations: While iPads have powerful chips (M series), optimizing performance on a mobile device is crucial.
Apple's Security and App Store Policies: These policies, particularly regarding code signing and the loading of dynamic libraries, pose limitations on supporting features like third-party C++ GD Extensions.
Swift UI as the Solution: The Xogot project leverages Swift UI to build a native iPad user interface. The key advantage of Swift UI, according to Miguel de Icaza, is its declarative approach and focus on a "source of truth," which simplifies UI updates based on data model changes.
LibGodot: A fundamental component of Xogot is the use of libgodot.a, a modular build of the Godot core engine. This allows Xogot to embed Godot views and content within the Swift UI application, enabling the mixing of native and engine elements.
Virtualization of Godot State: A significant technical achievement discussed is the virtualization of Godot's global state. This allows the Xogot application to run both the editor and a game instance simultaneously by "ping-ponging" a variable that points to the respective state.
"essentially every time that there's an access to a global variable... it would allocate it and instead what I did is I would have a big ass variable that contained the state of the whole app"
"and the trick is all you got to do is change that jro variable so J points there it's the editor then you change it and it points there and now it's the game"
Reorganizing the UI for iPad: To address the limitations and expectations of the iPad, the Xogot UI is being significantly redesigned. This includes:
Rewriting high-traffic dialogues in Swift UI.
Simplifying or removing features from the editor UI to save space, with the understanding that users can return to the desktop version for full configuration.
Adjusting the visual presentation of elements like font data.
Limitations of Xogot: Due to Apple's policies and the project's current stage:
Only GDScript is supported as the scripting language.
Third-party C++ GD Extensions are not supported, as dynamically loading code is restricted. Popular extensions may be bundled in the future.
Support for C# GD Extensions is also limited due to the need for Just-In-Time (JIT) compilation, which is generally restricted on iOS.
Ongoing Development and Beta Testing: The Discord conversations demonstrate active development, bug fixing, and beta testing with a community of users. Users are reporting bugs related to various aspects of the editor and engine, such as:
Invalid states in animations.
Issues with TileSets and TileMaps.
Crashes related to script editor tabs.
Visual bugs in the UI.
Problems with specific nodes and their properties (e.g., Label tab stop values, ColorRect).
Performance concerns, particularly on lower-end iPads.
Trouble with procedural sound generation.
Features Being Implemented and Explored: The team is actively working on and discussing various features:
Implementing native editors for different Godot components (TileSet, TileMapLayer, Animation, Debugger, Output).
Improving visual editors (e.g., for shaders, curves, gradients).
Adding paint functionality to the TileSet editor.
Supporting running games embedded within the editor.
Implementing features for managing projects and assets (e.g., rescanning the file system, supporting addons).
Adding support for external displays.
Exploring support for running local LLMs.
Considering support for Vision Pro and iPhone (though iPhone support is seen as more challenging due to the need for a full experience).
Discussing the implementation of Feature Tags for conditional code based on platform or configuration.
Monetization and Future Vision: There are discussions about the future of Xogot, including its potential cost and target audience. While there is testing of a paywall in the beta (with no actual charges), the final monetization model is not yet decided. Miguel de Icaza's vision seems to be more than just a simple port, aiming for an Apple Design Award and providing a robust game development experience on the iPad. There is also excitement about the potential for embedding Godot scenes within native iOS/Android/Mac apps using libgodot.
3. Godot Project Examples and Resources:
FPS Starter Kit: The KenneyNL FPS Starter Kit provides a concrete example of a Godot project, showcasing basic FPS features like a character controller, weapons, enemies, and the use of sprites and 3D models. This highlights the types of projects that can be created with Godot.
Godot Documentation as a Resource: The detailed documentation on Godot's features and development practices serves as a vital resource for developers using the engine, including those working with Xogot.
Most Important Ideas/Facts:
Xogot is a significant project to bring the full Godot Engine experience to the iPad. This is being achieved through a native Swift UI interface layered on top of the Godot core (libgodot.a).
The project addresses the unique challenges of mobile development, particularly input methods and UI design for touch interfaces.
Virtualizing Godot's internal state is a key technical innovation enabling the concurrent running of the editor and game.
Current limitations include limited support for third-party GD Extensions (C++ and C#) and only GDScript as the primary scripting language.
Xogot is in active beta testing, with ongoing bug fixing and the implementation of core editor features.
The future of Xogot includes potential monetization, expansion to other Apple platforms (iPhone, Vision Pro, Apple TV), and the possibility of embedding Godot content in native apps.
Godot's open-source nature under the MIT license is fundamental to projects like Xogot.
This briefing provides a snapshot of the information presented in the sources, highlighting the core concepts and current status of Godot engine development and the ambitious Xogot project.
FAQ
What is Xogot?
Xogot is an implementation of the Godot game engine specifically designed to run on Apple's iPad, with ongoing work to support iPhone as well. It aims to bring the full Godot editor and development experience to mobile devices.
How does Xogot differ from the standard Godot editor?
While Xogot uses the core Godot editor functionalities (through libgodot.a and creative use of GD extensions), it features a completely rewritten user interface using Swift UI. This new UI is optimized for touch input and the constraints of a mobile device, with larger tap targets and a focus on a more streamlined experience. It intentionally removes some configuration options deemed less essential for a mobile workflow, assuming users can utilize the desktop version for more advanced settings if needed.
What programming languages are supported in Xogot?
Currently, only GDScript is officially supported in Xogot. Due to Apple's security restrictions, dynamic libraries (like those used by C++ GD extensions) are not allowed to be added after the application is approved for the App Store. There are plans to potentially bundle popular C++ extensions directly into the Xogot binary in the future. C# is also not currently supported, likely due to limitations with Just-In-Time (JIT) compilation on iOS.
Can I use my existing Godot projects with Xogot?
Yes, you can use your existing Godot projects with Xogot. You can transfer your project folder to the iPad and open it in the Xogot application. Projects created in the desktop version of Godot can be opened and edited in Xogot, and vice-versa.
Are there any limitations to using Xogot compared to the desktop version?
Yes, there are some limitations. As mentioned, only GDScript is currently supported, and third-party C++ GD extensions cannot be dynamically loaded. The UI is also streamlined, meaning some advanced configuration options might be missing or presented differently. There have also been reports of some specific functionalities, like certain animation properties, TileSet/TileMap editing nuances, and debugger output, still being refined and having some bugs or limitations compared to the desktop version.
What is the licensing model for Xogot?
The Xogot application is currently in a beta testing phase via TestFlight. While there have been discussions and testing of in-app purchases and a "paywall" during the beta, any purchases made during this phase do not actually charge the user. The final pricing and monetization strategy for Xogot have not been officially announced, but the developers are aware of community concerns about pricing and sustainability. The core Godot engine and the assets included in the KenneyNL/Starter-Kit-FPS, which Xogot builds upon, are released under permissive licenses (MIT and CC0 respectively).
How can I get access to the Xogot beta?
The Xogot beta is available through Apple's TestFlight program. You need to sign up using a form, typically providing your TestFlight ID or Apple ID. Invites are sent out in batches, so there might be a waiting period after signing up. Information regarding the sign-up process is usually shared within the Xogot community channels (like Discord).
What are the main goals of the Xogot project?
The primary goal of Xogot is to provide a powerful and user-friendly Godot editor experience on the iPad (and eventually iPhone). This involves adapting the existing Godot core to the mobile environment, creating a touch-optimized UI, and ensuring compatibility with desktop Godot projects. The project also aims to utilize and contribute back to the Godot engine itself, such as integrating Metal rendering backend support. There's also a desire to cater to both existing Godot developers who want to work on the go and potentially new developers looking for a mobile-friendly game development tool.
Integration Note
Hello! I am here to act as your paid consultant and thought partner, drawing upon the documentation and conversation history you've provided to help you quickly analyze information and develop strategic recommendations. I have access to excerpts from the Xogot App Store release notes, documentation on differences between Xogot and Godot, Godot export documentation for iOS, Xogot FAQ, Xogot Getting Started guides, Reddit discussions about Godot on mobile and iOS, Godot 4.4 documentation, Xogot documentation on various topics like UI, assets, controls, TestFlight notes, a blog post about Xogot on iPadOS, Product Hunt reviews, the Xogot App Store listing, and Discord chat logs related to Xogot features, bugs, and discussions. I can help you navigate these materials, understand complex topics, and formulate well-supported insights.
Xogot is designed to integrate closely with existing Godot development workflows and tools, aiming to provide a native iPad experience that complements, rather than replaces, desktop Godot usage. The core principle is to build upon the powerful, open-source Godot engine, making it accessible and effective on a touch-first device like the iPad.
Here's a detailed breakdown of how Xogot integrates with existing Godot workflows and tools:
Project Compatibility and Mobility: A fundamental aspect of Xogot's integration is project compatibility. Projects created in Xogot are intended to be fully compatible with the desktop edition of Godot. This allows users to move projects back and forth between the two platforms.
Importing Projects: Existing Godot projects can be brought into Xogot using the Files App integration. This involves saving project files to a location accessible by the Files App (like iCloud Drive) and then copying them into the Xogot folder on the iPad. If the project is large, re-importing assets can take some time.
Using Version Control: Xogot recommends using native iOS Git clients like Working Copy, which integrates with the Files App. Users can clone repositories directly into the Xogot projects area or add existing project folders in Xogot as linked repositories in Working Copy. Pushing changes and using linked folders with Working Copy requires a Pro unlock. While Xogot itself does not have native Git support, this workflow allows users to manage their Godot projects with Git on the iPad.
Exporting Projects: Xogot currently supports exporting projects to WebAssembly, which can be shared via a link for playtesting in a web browser. Other export options, such as exporting for iOS (which requires a macOS machine and Xcode), Android, Windows, or other platforms, must be done using Godot on the desktop. The process for exporting a Godot project to Xcode for iOS development involves using the Godot editor's export window on macOS, setting up required Apple Developer account information, and then building and deploying from Xcode. For active development, Godot project files can be linked directly into an Xcode project to avoid re-exporting after every change.
User Interface and Experience: Xogot's UI is a significant area of adaptation from standard Godot. It is specifically designed to be touch-friendly and align with iPadOS conventions.
iPadOS Adaptation: This includes making UI elements more tappable, simplifying parts of the interface to conserve screen real estate, and replacing some toolbar icons with Apple's SF Symbols. Tooltips, which rely on hovering, are not surfaced due to the iPad's touch interface.
Hybrid UI Approach: Instead of fully rewriting the entire Godot editor UI in SwiftUI, Xogot uses a hybrid approach. It has a native SwiftUI shell that embeds Godot views as a library (libgodot). High-traffic or critical dialogues are being rewritten natively in SwiftUI for a better touch experience, such as the TileSet and TileMapLayer editors, the Audio bus editor, and the Shader Editor. Less frequently used or plugin-specific UI elements might still embed the original Godot views.
Differences from Godot UI: While aiming for a native feel, this results in some differences from the desktop Godot UI. For example, Project Settings navigation is adapted. Some users miss the classic Godot node icons, though Xogot offers an option to use them instead of SF Symbols. There are ongoing discussions and work based on user feedback to tune the UI and bring back or adapt features for a better workflow on iPad.
Supported Scripting and Extensions: A key difference and limitation in Xogot compared to desktop Godot is the supported scripting languages and extensions.
No Compiled Languages: Support for other compiled languages like C#, C++, Swift, or Rust is not included in Xogot. This means projects or addons written in these languages are unlikely to work directly in Xogot. While Godot 4.2+ experimentally supports exporting C# projects to iOS, this is a function of the desktop editor, not Xogot itself. Adding support for C# or arbitrary compiled GDExtensions in Xogot is not currently planned due to technical hurdles related to Apple's policies on arbitrary code execution and toolchain inclusion.
GDScript Addons: Addons and plugins written solely in GDScript are supported and can be enabled via project settings. Users place the addon code in the 'addons' directory within the project folder.
Editor Functionality: Xogot provides access to most core Godot editor functionalities, adapted for the iPad experience.
Editors: Includes dedicated editors for 2D and 3D scenes, a script editor, animation editor, and tilemap/tileset editors. Recent improvements have focused on native SwiftUI rewrites for key editors like TileSet and TileMapLayer.
Inspector and Settings: The Inspector and Project Settings panels are available, with some UI adaptations for iPad. All Project Settings from Godot are intended to be available, though the UI for navigating them is different.
Debugger: A fully integrated debugger is included, supporting breakpoints, exploring program state, and profiling. Runtime errors are surfaced with descriptions.
Asset Importing: Supports common asset types (sprites, textures, sounds, 3D models) and provides multiple ways to import them directly on the iPad via Files App or drag and drop. Specific formats like .gltf and .obj for 3D models are supported with notes on required accompanying files.
Input Handling: Provides support for various input devices, including external keyboards, mice, and Bluetooth controllers. A notable feature is the built-in iOS virtual controller, which maps to Xbox button conventions and can be configured via the Input Map in Project Settings. This allows quick testing of desktop projects on iPad without requiring custom touch controls. Users can also manually add touch controls like the Virtual Joystick Addon. There have been reports and fixes related to multi-touch event handling in the editor and running games. Support for accelerometer/gyroscope is available but might require exporting the game to test fully.
Rendering: Xogot is based on Godot 4.4+. It supports Godot's rendering engines (Metal, Vulkan) and rendering methods (Mobile, Forward+, OpenGL), configurable in Project Settings. Metal backend support is integrated.
External Displays and Multitasking: Supports iPadOS multitasking features like Split View and Stage Manager, allowing work across multiple displays.
Learning Resources: Xogot includes integrated learning resources to help users get started.
Documentation: Provides integrated API documentation and tutorials. This includes Xogot-specific guides (like Getting Started, UI, Importing Assets, Onscreen Controls, Working with Git) and documentation on differences from Godot. Links to the official Godot documentation are also beneficial.
Sample Projects: Comes preloaded with sample projects in the "Learning Center" to help users explore features.
In summary, Xogot functions as a Godot editor specifically tailored for iPadOS. It maintains project compatibility with desktop Godot, allowing developers to seamlessly transition their work. While it adapts the UI for touch and leverages native iOS features, it currently focuses on GDScript and doesn't support compiled languages or arbitrary GDExtensions, requiring desktop Godot for projects dependent on these. Core editor functionalities are present and being actively refined for the touch environment, alongside built-in learning resources.
As a next step, considering the focus on compatibility and the unique iPad workflow, you might want to investigate the specific performance characteristics of Xogot compared to desktop Godot for different types of projects (e.g., 2D vs 3D, asset heavy vs code heavy) to understand the practical limitations and ideal use cases for developing solely or partially on iPad.
Technical Considerations and Limitations Note
As your paid consultant and thought partner, I will now detail the unique technical considerations and limitations when using Xogot, drawing upon the documentation and conversation history you've provided. I have access to a range of materials including release notes, documentation on differences and features, Godot export guides, Reddit discussions, and Discord chat logs, which allow me to analyze Xogot from technical, operational, and user perspective.
Xogot is built upon the robust Godot engine but is specifically engineered for the iPadOS environment, which introduces several technical considerations and limitations that differ from the standard desktop Godot experience. These considerations are primarily driven by the architecture of iPadOS, Apple's platform policies, and the design choices made to optimize for a touch-first interface.
Here is a detailed breakdown of the unique technical considerations and limitations:
Core Architecture and Process Management:
Xogot employs a hybrid architecture, using a native SwiftUI shell to embed Godot engine views via libgodot. This approach allows for a more native iPadOS feel while leveraging the core Godot functionality.
A major technical hurdle overcome was the iPadOS restriction on running multiple processes simultaneously. Unlike the desktop Godot editor, which launches a separate process for running a game, iPadOS does not allow a child process to run alongside the parent application.
To address this, the Xogot team had to "virtualize" Godot, modifying its core to allow multiple instances to run within a single application process. Early attempts involved manually resetting the entire Godot state when switching between the editor and running the game. A more robust solution was achieved by making Godot's root singleton thread-local storage and managing separate graphics contexts. This complex adaptation ensures the editor and the running game can coexist within the same application, enabling features like the integrated debugger.
Scripting Language Support (Limited to GDScript):
A significant limitation is that Xogot exclusively supports Godot's built-in scripting language, GDScript.
Compiled languages such as C#, C++, Swift, or Rust are not supported. The technical challenge here is substantial; supporting languages like Swift would require embedding the entire Swift compiler and toolchain within the app, which is not currently planned. Godot's recent transition from Mono to CoreCLR further complicates C# support specifically for the iOS platform.
GDExtension and Plugin Support (GDScript Only):
Related to scripting, Xogot only supports addons and plugins written purely in GDScript.
Compiled GDExtensions written in languages like C++ or C# are not supported. This limitation stems from Apple's App Store policies, which generally prohibit applications from loading arbitrary third-party dynamic libraries for security reasons.
For popular GDExtensions to work in Xogot, they would need to be specifically ported to be multi-instance compatible and then potentially bundled directly within the Xogot application binary after careful consideration and porting efforts. Users have voiced interest in support for specific extensions like Godot-Jolt and Godot-Voxel.
User Interface Adaptation and Hybrid Implementation:
While Xogot is built on Godot, its user interface is heavily adapted for iPadOS to be touch-friendly, leading to differences compared to the desktop editor. This involves larger tappable regions, simplified layouts, and the use of SF Symbols instead of standard Godot icons in many places.
Not all parts of the UI have been rewritten in SwiftUI. High-traffic areas like the TileSet, TileMapLayer, Audio bus, and Shader editors are being rebuilt natively for a better touch experience. However, less frequently used components or third-party plugins may still display the original Godot UI, resulting in a sometimes inconsistent visual style.
Certain interactions common in desktop Godot may be missing or adapted. For example, tooltips are not available due to the lack of hover on touch devices. Standard keyboard shortcuts are supported with an external keyboard, but some desktop interactions like tabbing between inspector properties can be tricky to implement in the adapted UI. Users have also noted differences in behaviors like dragging objects accidentally triggering other editor windows.
Performance and Memory Constraints:
Memory usage is a key limitation on iPads, particularly for larger projects or on devices with less RAM. Users have reported low memory warnings and crashes, especially with projects that run many print statements or are generally asset-heavy.
There have been ongoing efforts to reduce memory consumption and fix leaks. Memory spiking when the app is sent to the background was identified as a cause of crashes.
While modern M-series chips on iPads offer significant processing power, available RAM appears to be a more critical factor for smooth performance in Xogot.
Input Handling Specificities:
Xogot supports external keyboards, mice, and Bluetooth controllers, providing a familiar experience for desktop users.
A unique iOS-only feature is the built-in virtual controller, configurable in Project Settings. This maps to Xbox conventions and allows for testing games designed for controllers without implementing custom touch controls. However, it offers less customization than using a GDScript-based virtual joystick addon.
Handling multi-touch input in both the editor and running games has presented challenges, with bugs reported regarding simultaneous touch events and the distinction between raw touches and pan/magnification gestures. The input system has been modified and is not the same as vanilla Godot, which impacts upstreaming fixes.
Apple Pencil support is present, allowing for fine detail work, but features like hover input may not be fully supported by Godot itself.
File System Integration and Version Control Workflow:
Xogot leverages the iPadOS Files App for project and asset import/export. This allows transferring projects via iCloud Drive, local storage ("On My iPad"), or connected external drives. Drag and drop is supported for assets.
While projects can be saved to external locations, direct integration with cloud storage like iCloud Drive required adopting complex asynchronous File IO APIs and was not initially fully supported for saving.
Xogot does not have built-in Git support. The recommended workflow involves using a separate native iOS Git client like Working Copy, which integrates with the Files App. This requires using features like cloning into the Xogot folder or adding the project folder as a linked repository. Some advanced Git features require a Pro unlock in Working Copy. Command-line Git can also be used via an iSH terminal with mounting the Xogot directory.
A potential pitfall when moving projects between desktop OSes (Windows/Mac, which are typically case-insensitive) and iPadOS (which is case-sensitive) is issues arising from inconsistent file or folder casing.
Exporting and Deployment Limitations:
Currently, Xogot supports exporting projects to WebAssembly for playtesting via a hosted link. This feature hosts the build on share.xogot.com for a limited time.
Exporting to other platforms (such as native iOS apps, Android, Windows, etc.) must be done using the desktop version of Godot. The process for building a native iOS app from a Godot project requires a macOS machine, Xcode, export templates, and an Apple Developer account. Direct native iOS app building/deployment from Xogot is not a current feature, although it is a desired capability. The "Export" option in Xogot currently initiates iOS and WebAssembly exports.
Device and OS Version Requirements:
Xogot requires iPadOS 18.0 or later and an iPad with an A12 Bionic chip or newer. This is due to reliance on APIs introduced in iOS/iPadOS 17 and extensively in 18.
Older iPadOS versions are not supported.
While the app can be installed and partially used on iPhones running iOS 18, the UI is not optimized for smaller screens, and some features may not work correctly.
It runs on VisionPro as the iPad app, not a dedicated build.
These technical considerations mean that while Xogot offers a powerful Godot development experience on the iPad, it functions best as part of a larger workflow that may still require a desktop machine for tasks like building final native apps or utilizing plugins written in compiled languages. The ongoing development is actively addressing many of these points, particularly around UI native-ness and core editor functionality adapted for touch and memory constraints.
Considering these points, a potential next step for analysis could be to delve into how these specific technical limitations translate into workflow friction for different user segments (e.g., hobbyists, professional indies, developers building plugins or using advanced features) and identify which limitations are most critical for improving the value proposition of Xogot as a standalone development environment.
Version Control and Collaboration Note
As your paid consultant and thought partner, let's delve into how Xogot approaches version control and collaboration for Godot projects, drawing upon the information available in the sources you've provided. Understanding these mechanisms is crucial for assessing workflow efficiency and scalability, which can inform strategic recommendations.
Xogot enables version control and collaboration for Godot projects primarily by leveraging the native file management capabilities of iPadOS and recommending the use of external, dedicated applications for Git integration. It does not feature a built-in Git client within the application itself, a decision influenced by the technical constraints and platform policies of iPadOS.
Here's a detailed breakdown of how this is facilitated and the considerations involved:
Leveraging iPadOS Files App Integration:
The foundation of Xogot's approach lies in its deep integration with the iPadOS Files App. This allows users to store their Godot projects and assets in locations accessible by other apps on the iPad, such as iCloud Drive, "On My iPad" storage, or connected external drives.
This integration means that the actual project files (.godot folder, .tscn, .gd, .png, etc.) reside within the standard iPadOS file system, making them visible and manageable by any application that can interact with files in those locations.
Recommended Method: External Git Clients (Specifically Working Copy):
Because Xogot itself does not include Git functionality, the recommended workflow for version control involves using a separate, native iOS Git client. Working Copy is explicitly endorsed and recommended for this purpose.
Working Copy integrates seamlessly with the Files App, allowing it to access and manage the project files stored in the Xogot folder or other locations accessible via Files.
To use Working Copy with a Xogot project, users can either clone a Git repository directly into the Xogot folder using Working Copy, or add an existing Xogot project folder as a "Linked Repository" within Working Copy.
This enables users to perform standard Git operations – such as committing changes, pushing to and fetching from remote repositories (like GitHub or GitLab), branching, etc. – using the Working Copy interface. Xogot automatically reflects file changes made by Working Copy due to the Files App integration.
It is noted that certain advanced features in Working Copy, like pushing changes and using linked folders, may require a "Pro" unlock.
Users have confirmed that they successfully use this workflow with services like GitHub.
Alternative Method: Command-Line Git via iSH:
For users who are comfortable with command-line interfaces, the documentation also suggests using iSH, a Linux shell emulator for iPadOS, to manage Git repositories.
This involves installing Git within iSH, mounting the Xogot project directory to the iSH file system, and then running standard Git commands from the iSH terminal within that mounted directory.
Reasoning for No Built-in Git:
The decision not to include a built-in Git client or support traditional Godot Git plugins stems from the architectural limitations and security policies of iPadOS and the Apple App Store.
Apple's policies generally restrict applications from loading arbitrary third-party dynamic libraries or executing arbitrary code from outside the app's sandbox. This makes it technically challenging, if not impossible under standard App Store distribution, to bundle and run a generic Git client library or Godot's desktop-style Git plugin within the Xogot app.
Additionally, the core changes made to Godot to run within a single process on iPadOS, allowing the editor and game to coexist ("virtualizing" Godot), likely impact how tightly integrated external tools like Git plugins could be.
Implications for Collaboration:
This file-system-based approach, combined with external Git clients, directly supports collaborative workflows. Teams can store their Godot project in a shared Git repository (e.g., on GitHub).
Developers using Xogot on their iPads can pull the latest changes from the repository, work on the project locally using Xogot, and then commit and push their changes back to the shared repository using their Git client (like Working Copy).
This allows multiple team members, whether they are using Xogot on iPad or desktop Godot on Windows, macOS, or Linux, to contribute to the same project. Projects created in Xogot are compatible with desktop Godot and vice versa.
The "Share Your Work" feature, which exports projects to WebAssembly for easy playtesting via a hosted link, also facilitates a form of collaboration by enabling rapid feedback loops on playable builds, although it's not direct code collaboration.
Limitations and Considerations:
No In-Editor Git UI: A significant limitation compared to desktop IDEs or the standard Godot editor with a Git plugin is the lack of a fully integrated Git user interface within Xogot itself. Users must switch to a separate app (Working Copy or iSH) to perform version control operations.
Case Sensitivity: A potential pitfall when collaborating on projects stored in Git and shared between desktop operating systems (like Windows or macOS, often case-insensitive file systems) and iPadOS (a case-sensitive file system) is that inconsistent casing in file or folder names can lead to issues or errors when opening or running the project on iPadOS. Users have reported encountering errors related to this when importing projects.
Workflow Friction: The necessity of using external apps adds steps to the development workflow compared to environments with integrated Git.
In summary, Xogot enables version control and collaboration by relying on standard iPadOS file management and external Git applications. While it lacks built-in Git features due to platform constraints, this approach facilitates interoperability with desktop Godot workflows and allows teams to use established Git-based collaboration models.
A potential next step in analysis could be to evaluate the degree of workflow friction introduced by this external Git dependency for typical Godot development tasks (e.g., committing frequently, resolving merge conflicts) and how this might impact the appeal of Xogot as a primary development environment compared to a supplementary one for on-the-go work.
