This repository provides the FMOD Studio integration for Unity, enabling audio middleware functionality in Unity games. It consists of runtime components (MonoBehaviours like StudioEventEmitter, StudioListener, and StudioBankLoader) that interface with the native FMOD API via C# wrappers (fmod.cs and fmod_studio.cs), and extensive editor tools for setup, event browsing, bank management, and reference updating. The architecture features platform abstraction via a base Platform class with platform-specific subclasses, a Settings ScriptableObject for configuration, and reusable patterns like attribute/drawer systems for referencing FMOD events, parameters, and banks. Key entry points include RuntimeManager for initialization, StudioEventEmitter for playback, and editor windows such as EventReferenceUpdater for migrating obsolete references. The system handles 3D audio, Unity Timeline integration, and platform-specific binary loading across iOS, Android, Windows, macOS, Linux, WebGL, Apple TV, and VisionOS.
UIWidgets is a Flutter-inspired UI framework for Unity that enables cross-platform app development within the Unity Engine. It consists of a C++ engine layer (modified Flutter engine) for rendering and a C# runtime layer providing widget libraries (Material and Cupertino), gesture handling, animation systems, and platform integration. The primary entry point is the UIWidgetsPanel component attached to a Unity Canvas, which hosts the UIWidgets view. The framework powers applications like Unity Connect App and Unity Chinese Documentation, featuring samples demonstrating widgets, animations, gestures, and platform-specific integrations. While the core framework exhibits strong architectural patterns, the codebase shows technical drift due to version-specific Unity tight coupling, platform fragmentation, and engine fork maintenance burdens.
BundleMaster is a Unity asset management system for handling AssetBundles with synchronous/asynchronous loading, reference counting, and hot-update capabilities. The architecture consists of core runtime components (BundleMasterRuntime/), platform-specific adapters (WebGL, Nintendo Switch), editor tools for configuration and building, and utility systems for threading and cryptography. Key entry points include AssetComponent.Load()/LoadAsync() for asset loading, AssetComponent.Initialize() for bundle setup, and AssetComponent.Update() for maintenance. The system manages asset lifecycles through reference counting and periodic unloading pools, supports encrypted/obfuscated asset bundles, and provides editor workflows for building asset bundles with version tracking.
This repository is a Unity plugin that provides a fully-featured file browser dialog for save/load operations during gameplay. It supports file and folder selection, multi-selection, search, filtering, context menu operations (rename, delete, create folder), window drag/resize, and runtime theming. The plugin uses a singleton pattern to ensure only one dialog is open at a time and offers coroutine-based methods (WaitForSaveDialog/WaitForLoadDialog) for seamless integration with Unity's async system. The architecture is structured as a set of Unity scripts, prefabs, and assets. The main controller is FileBrowser.cs, which manages the dialog lifecycle and UI interactions. FileBrowserHelpers.cs abstracts file system operations across platforms, with special handling for Android's Storage Access Framework (SAF) via native Java code compiled into an .aar. The UI is built with Unity's uGUI system and includes a recycled list view for efficient rendering of large directories. Skinning is handled by UISkin.cs, a ScriptableObject that defines colors, fonts, and sprites. The plugin also includes Android-specific Java classes for directory picking and permission requests. Key patterns include object pooling (RecycledListView), platform abstraction (FileBrowserHelpers), theming via scriptable objects (UISkin), and coroutine support. The Android integration is particularly noteworthy, as it handles the complexities of the Storage Access Framework for file operations on modern Android versions. The plugin is designed to be embedded in any Unity project and is distributed as a Unity package via the Asset Store or OpenUPM.
BeatSaber-IPA-Reloaded is a mod loader for the Unity game Beat Saber. It injects into the game process via a native DLL proxy (Doorstop) that hooks winhttp.dll during Unity's startup to load a managed injector assembly. The injector bootstraps the loader, which discovers and manages plugins, handles dependency resolution, configuration, logging, and anti-malware scanning. The repository comprises several assembly projects: a native proxy (C++), a managed injector (C#), the loader itself, a command-line patcher/installer, and a meta-project that assembles the final output. The loader features an advanced configuration system that uses System.Reflection.Emit to dynamically generate type-safe config stores with automatic serialization, change tracking, and thread-safe locking. Plugin dependencies are resolved via topological sorting with cycle detection and conflict handling. The logging subsystem supports pluggable printers for console, file, and compressed output. The code demonstrates high craftsmanship in IL emit code generation, dependency graph algorithms, and fast reflection accessors. However, some parts show age (deprecated thread abort calls, obsolete plugin interfaces) and tight coupling between assemblies via InternalsVisibleTo attributes. Overall, it is a solid mod loader with several reusable components.
This repository is a collection of sample applications and plugins for Android game development, maintained by Google. It demonstrates integration of the Android Game Development Kit (AGDK), Google Play Games Services, Play Asset Delivery, Adaptive Performance (ADPF), Game Mode, game controllers, and more. The samples span multiple engines: native C++ (NDK), Unity, Unreal Engine, and Godot. Each sample is a self-contained project with its own entry points (e.g., `android_main()` for native apps, `MainActivity` for Java, Unity scenes, Unreal game instances). The architecture varies per sample but commonly follows a scene-based game loop with a `SceneManager` singleton, input handling via cooked events, and rendering through either OpenGL ES or Vulkan via the `simple_renderer` abstraction. External dependencies include the Android SDK/NDK, Google Play Services libraries, and third-party libraries like glm, Bullet Physics, and Dear ImGui. The repo also includes utility tools like a Tuning Fork validation tool and Unity plugins for ANR detection and memory monitoring. While many components are well-crafted and reusable (e.g., `simple_renderer`, `base_game_framework`, `ndk_helper`), there is significant code duplication across samples and some use of deprecated APIs, indicating a moderate level of technical drift.
UnityNativeShare is a Unity plugin library that enables native file and text sharing on Android and iOS platforms. The codebase consists of a C# Unity plugin (NativeShare.cs) that provides a fluent API for sharing content, with native implementations in Java for Android and Objective-C++ for iOS. The Android implementation uses a ContentProvider for secure file sharing and includes custom share dialog support for callback reliability across different Android versions. The iOS implementation uses UIActivityViewController with proper memory management for share result callbacks. The architecture follows a standard Unity plugin pattern with platform-specific native code wrapped by C# interfaces. Key entry points are the NativeShare class methods (AddFile, SetText, Share) and the native callback receivers (NSShareResultCallbackAndroid, NSShareResultCallbackiOS). The plugin handles platform-specific edge cases including Xiaomi/MIUI device quirks, Android 11+ package visibility requirements, and iOS photo library permissions. However, the README explicitly states this asset is no longer maintained, which is a critical finding. While the code demonstrates solid craftsmanship for its time, the lack of active maintenance means compatibility with newer OS versions (Android 13+, iOS 16+) is uncertain. The technical debt includes potential issues with newer Android package visibility changes and iOS share sheet behavior modifications.
This repository is a curated list of open-source Unity projects and tools, organized by categories such as shaders, editor extensions, UI components, scripts, mobile plugins, and more. It contains no source code itself; it serves as a directory of links to external repositories. The list is comprehensive and well-organized, making it a valuable resource for Unity developers seeking reusable components, learning materials, and inspiration. However, as a list, it does not demonstrate any code craftsmanship, architecture, or reusability of its own.