Jia Tolentino on The Cazalet Chronicles for The New Yorker

“The Cazalet Chronicles” by Elizabeth Jane Howard offers a richly woven narrative of an English family’s life amid societal upheaval, yet remains underrated and underappreciated compared to similar literary works.

Continue reading →

9to5Mac Reports Apple Notes Will Gain Markdown Export at WWDC, and, You’ll Be Unsurprised to Know, I Have Thoughts

…it shouldn’t be possible to have a malformed note in Apple Notes.

I honestly don’t know Gwoober’s voice well enough to tell whether or not he is suggesting he’s not ever seen malformation in Apple Notes because uh…

Sowwweeee buddy!

Latest Color Names

Latest Colornames Palette This is an automatically-generated palette of the latest entries on colornames.org created by my Siri Shortcut. :) c8466e

Continue reading →

5-31-2025 Misc

Updated 05312025-233104

“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.

Xogot | Documentation
archived 31 May 2025 20:39:12 UTC

XodotLM

Audio Overview

Timeline

Timeline of Events

Cast of Characters

Study Guide

Quiz

  1. What is the primary purpose of the KenneyNL/Starter-Kit-FPS on GitHub?
  2. What type of license governs the use of the software in the KenneyNL/Starter-Kit-FPS?
  3. What are some of the features included in the KenneyNL/Starter-Kit-FPS?
  4. What is the main focus of the godotengine/godot-docs GitHub repository?
  5. Under what license are the files in the classes/ folder of the godot-docs repository distributed?
  6. What is Xogot, and what platform is it primarily being developed for?
  7. Why did Miguel de Icaza decide to rewrite the UI for Xogot using Swift UI instead of using the existing Godot editor UI directly?
  8. What are two major limitations of Xogot mentioned regarding language support and extensions?
  9. According to the Xogot Discord discussions, what are some of the editor components that have been rewritten using SwiftUI?
  10. 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

  1. 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.
  2. The software in the KenneyNL/Starter-Kit-FPS is governed by the MIT License.
  3. Features include a character controller, weapons and weapon switching, enemies, and CC0 licensed sprites and 3D models.
  4. The godotengine/godot-docs repository contains the official documentation for the Godot Engine.
  5. The files in the classes/ folder are distributed under the MIT license, with the same authors as the main Godot source repository.
  6. Xogot is a project to bring the Godot game engine editor to the iPad, built using Swift UI.
  7. 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.
  8. Xogot currently only supports GDScript, and third-party C++ GD extensions are not supported due to Apple’s security requirements for loading dynamic libraries.
  9. Rewritten components include the TileSet and TileMapLayer editors, SpriteAnimationEditor, Animation editor, Debugger, and Output.
  10. 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

  1. 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?
  2. 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.
  3. 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?
  4. 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?
  5. 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:

Key Themes and Important Ideas:

1. Godot Engine: Open-Source, Feature-Rich, and Community-Driven

2. Xogot: Bringing Godot to the iPad with Swift UI

3. Godot Project Examples and Resources:

Most Important Ideas/Facts:

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?

How does Xogot differ from the standard Godot editor?

What programming languages are supported in Xogot?

Can I use my existing Godot projects with Xogot?

Are there any limitations to using Xogot compared to the desktop version?

What is the licensing model for Xogot?

How can I get access to the Xogot beta?

What are the main goals of the Xogot project?

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:

  1. 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.
  2. 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.
  3. Supported Scripting and Extensions: A key difference and limitation in Xogot compared to desktop Godot is the supported scripting languages and extensions.
    • GDScript Only: Xogot exclusively supports Godot’s built-in scripting language, GDScript.
    • 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.
  4. 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.
  5. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

Latest Color Names

Latest Colornames Palette This is an automatically-generated palette of the latest entries on colornames.org created by my Siri Shortcut. :) 085590

Continue reading →

My robots.txt File

A humorous invitation encourages the reader to either leave or stay, particularly welcoming users of wget.

Continue reading →

Latest Color Names

Latest Colornames Palette This is an automatically-generated palette of the latest entries on colornames.org created by my Siri Shortcut. :) 48542a

Continue reading →

ICEGary

The speaker reflects on their late stepfather’s quirky practice of marking emergency contacts with “ICE,” which unexpectedly reappears in their phone, evoking fond memories despite his passing.

Continue reading →

Wipr 2 App Store Review

The Better Web solution for Apple Platforms… in a Good Way. Gourd Bless Kaylee for creating a (more or less) single tap solution to making WebKit browsing tolerable. Recommendable to literally anyone - those paranoid, detail-obsessed folks who care to explore the transparency of Wipr 2’s ongoing development will find the experience pleasant, while most of us can just trust in the (quite rigorous) behind-the-scenes process.

Continue reading →

home sweat hime

Images are presented without context or accompanying text.

Continue reading →

Delta Force App Store Review

Note: I did not play a single frame of this game and uninstalled it immediately upon realizing that it (at least as yet) does not have controller support. I’d been eagerly anticipating the idea of this game only the second ever flavor of first person shooter (after the CoDs) to the iOS/iPadOS platform for how many years now? Legitimately, I remember being a younger person when I first “preordered” the app download.

Continue reading →

Google Gemini Tries to Teach a Moa to Kite

A topic that a lot of us have been wrestling with. Gemini Share URL: g.co/gemini/sh… Google Doc: dub.sh/moagemini Transcript

Continue reading →

disport

Verb occupy in an agreeable, entertaining or pleasant fashion; “The play amused the ladies” Synonyms amuse divert Less specific entertain Related diversion recreation amusing amusive diverting entertainment amusement play boisterously; “The children frolicked in the garden”; “the gamboling lambs in the meadows”; “The toddlers romped in the playroom” Synonyms frolic lark rollick skylark sport cavort gambol frisk romp run around lark about Less specific play Related play frolic romp gambol caper romper play frolic romp gambol caper sport athletics escapade lark play frolic romp gambol caper disport - LookUp verb archaic humorous enjoy oneself unrestrainedly; frolic a painting of ladies disporting themselves by a lake | they disport as they please

Continue reading →

Latest Color Names

Latest Colornames Palette This is an automatically-generated palette of the latest entries on colornames.org created by my Siri Shortcut. :) f6ec80

Continue reading →

grift

Via Wikitionary: American criminal underworld slang, 1906 (noun), 1915 (verb), alteration of graft (“corruption, illicit profit through corrupt means, bribe, one’s occupation”), alteration perhaps influenced by similar sounding words, e.g. drift, etc., probably ultimately from Middle Dutch graft (“digging, ditch, canal, trench”) (modern Dutch gracht), related to Dutch graven (“to dig”), English grave (“to dig”).[1][2][3] IPA(key): /ɡɹɪft/ Rhymes: -ɪft grift (plural grifts) (US, slang) A confidence game or swindle.

Continue reading →

playlist hypothesis

noun …the baseline idea of a playlist’s premise, target audience, name, [and] songs.1 Each of these playlist drafts is mostly skeletal, consisting of what curators call a “hypothesis,” or basic premise and intended target audience (the more specific, the better), and a few representative songs. In developing them, Colomo will flesh out the playlists with more songs (Spotify’s magic number is 50 — generally between 3 and 3.5 hours' worth — which feels substantial but not overwhelming), a cover image that reflects the hypothesis at a glance, and a short written description, usually no more than one or two sentences.

Continue reading →

breviloquium

Breviloquium refers to the brevity or conciseness of speech.

Continue reading →

Write.as' Large Language Model Remains my Favorite

The following post was generated entirely using Write.as AI and left unedited. You’re welcome. Though I love to go, Tweetbot of anyone, but I think I disagree with the multilayered tables that “[Discord Nitro subscribers. Among quite a departure from snapping a “Mastodon, Twitter client. If I would be assigned and what I suspect it’s relevant of two gigabytes. The Bot Let’s say it’s much at any given from the aforementioned “lock-up clutch,” which should immediately screaming telepathically: *can you can use for no matter how useful in this matter](https://www.

Continue reading →

Gear.Club Stradale App Store Review

Gear.Club Stradale impresses with its visuals and controller support but ultimately fails to deliver a satisfying driving experience due to its inadequate physics engine.

Continue reading →

∆