gilzoide

SQLite-net brings the powerful SQLite-net library to Unity, enabling developers to access and manage SQLite databases with both synchronous and asynchronous APIs. The package includes SQLite3 Multiple Ciphers for encrypted database support, serialization/deserialization capabilities, CSV import functionality, and cross-platform support including WebGL with IndexedDB persistence. SQLiteAsset integration allows seamless management of read-only database files as Unity assets.

Flexbox components for Unity GUI using the Yoga layout engine. Provides a single FlexLayout component that brings modern flexbox layout capabilities to Unity UI with live edit-mode updates, multi-platform support, and seamless integration with existing anchor and layout element systems.

Simple Update Manager pattern + Jobified Update for MonoBehaviours

Asynchronously apply texture updates on the render thread without stalling the main thread, replacing Unity's standard Texture2D.Apply() method. Supports Built-in and Scriptable Render Pipelines with flexible scheduling options for per-frame or one-shot updates across Windows, Linux, macOS, Android, iOS, tvOS, visionOS, and WebGL.

Safe Area Layout is a Unity GUI layout group that automatically adjusts UI elements to respect device safe areas, eliminating notch and rounded corner issues on mobile devices. It integrates seamlessly with Unity's layout system, supports editor preview modes, and allows selective exclusion of child elements, making it ideal for cross-platform UI development.

Automatically generates a Gradle Wrapper (gradlew) when exporting Android projects in Unity, eliminating manual setup and version conflicts. Simply specify your desired Gradle version in Project Settings, and the plugin leverages Unity's bundled JDK and Gradle to create the wrapper—no additional installation required. Ensures all developers use the same Gradle version and enables compatibility with newer Gradle features unavailable in Unity's default version.

Player for Lottie animation files, powered by rlottie.

Gradient Rect provides Unity UI components that render gradients directly into mesh vertices, enabling rich color transitions without material manipulation. Supports color tints, textures, sprites, custom materials, masking, and mesh modifiers like Outline and Shadow, all while leveraging Unity's built-in Gradient class for seamless integration.

Automatically bind Camera viewports to RectTransforms, enabling seamless 3D model rendering directly into responsive UI elements without RenderTextures. Supports both Screen Space - Camera and Screen Space - Overlay canvas modes, with automatic camera enable/disable synchronization.

Use classes and other managed types with Unity's Job System

Automatically adjust Cameras' FOV to 3D objects bounds.

Key-Value Store save system interface and implementations

Configurable prefab instance pooling system that reduces instantiation overhead. Supports multiple deployment options (project assets, scene components, or embedded in scripts), prewarming, generic typing, pooled object callbacks, Addressables integration, and Inspector debugging for monitoring active and inactive instances.

Create custom Project Settings effortlessly by adding the [ProjectSettings] attribute to ScriptableObject subclasses. Settings automatically appear in the Project Settings window and can be loaded via simple API calls in editor and runtime code. Supports custom editors, multiple asset paths including ProjectSettings folder, and both Project and User settings scopes.

Gesture Recognizer scripts based on Input and EventSystem handlers

Cloud Save provides a unified interface for implementing cross-platform cloud save functionality in Unity games. It supports iOS/macOS via Game Center + iCloud, Android via Google Play Games Services, and the Unity Editor, enabling developers to write multiplatform save logic once while abstracting platform-specific implementations.

Manage ESC/Android Back button events with a stack-based system that ensures only the topmost object handles input. Inherit from ABackButtonHandler for automatic stack management via OnEnable/OnDisable, or implement IBackButtonHandler for pure C# classes. Includes a custom inspector for debugging the active stack during play mode.

Serializable versions of Dictionary, HashSet and KeyValuePair for Unity

Create Unity UI graphics with rounded corners directly in their meshes. RoundedRect, RoundedTexture, and RoundedImage components eliminate the need for extra textures or masks to achieve rounded corner effects at any size. Features independent corner radius configurations, custom material support, mesh modifier compatibility, and automatic sprite UV handling.

ScriptableObject that automatically aggregates assets using AssetDatabase.FindAssets

Conditionally modify GameObjects and Components at import time based on build configurations, with zero runtime overhead. Supports editor vs built player detection, development vs release builds, scripting define symbols, and platform-specific conditions. Use PropertyModifier to change component values, KeepObjectsModifier to conditionally include elements, or DeleteObjectsModifier to remove them—perfect for managing platform-specific UI, debug features, and build-variant assets.

Fast and memory efficient implementation of C#'s ISet for enums, storing data as bit masks.

SQLite Asset enables read-only SQLite database assets in Unity, automatically importing .sqlite, .sqlite2, and .sqlite3 files. Create connections to your databases with a single method call, with flexible loading from Streaming Assets or memory depending on platform requirements. Built on SQLite-net for reliable database management.

Fast and memory-efficient C# `ISet` implementation for enums using bit masks. Supports enums up to 32 or 64 values with zero-allocation operations and non-boxing conversions. Includes serialization support and custom property drawers for Unity 2020+ or earlier versions.

Wraps .NET TaskFactory and TaskScheduler objects as configurable MonoBehaviour and ScriptableObject components for Unity. Provides multiple TaskScheduler implementations—SyncTaskScheduler for main thread execution, ManagedThreadPoolTaskScheduler for thread pool tasks, and OwnThreadsTaskScheduler for custom-managed threads—with configurable concurrency limits to streamline asynchronous task management in your projects.

Preset for components that can be applied at runtime

Tween engine for Unity powered by the C# Job System and Burst compilation for high-performance animations. Supports tweening floats, vectors, quaternions, colors, and rects with highly configurable easing, duration, loops, and time scaling. Includes serializable tweener classes and ready-made components for seamless integration into your projects.

Measure and optimize audio output latency in your Unity projects. Provides utilities to detect and quantify delays between audio playback requests and actual speaker output, essential for rhythm games, real-time audio applications, and any project requiring precise audio timing synchronization.

Simple helper class for registering/unregistering systems in the PlayerLoop

Store and sync player data across Apple devices using iCloud Key-Value Store. This package provides a Key-Value Store implementation backed by iCloud KVS, enabling seamless data persistence on macOS, iOS, tvOS, and visionOS. Supports standard data types with optional custom object serialization through the base Key-Value Store interface.

Tessellate vector paths in Unity using the lyon library. Supports both fill and stroke rendering with an intuitive API for path building and tessellation. Features multithreaded processing via Unity's Job System and Burst compiler, memory reuse, and prebuilt binaries for Windows, Linux, macOS, iOS, and Android.

Securely store key-value data on Apple platforms (macOS, iOS, tvOS, visionOS) using native Keychain Services. This package implements the Key-Value Store interface with support for Generic Password Keychain Items, iCloud synchronization, access groups, and data protection features. Ideal for storing user credentials, preferences, and sensitive game data with platform-native security.

Import JavaScript code as <script> tags in WebGL builds' index.html file

High level C# to Objective-C interface, similar to AndroidJavaClass and AndroidJavaObject

Adds PlayerSettings.WebGL.emscriptenArgs to the Project Settings UI

Easily import ".csv" files as read-only SQLite database assets.

Task/UniTask-based Main Thread dispatcher, no GameObjects involved

Adds context menu items to quickly populate Component references using GetComponent, GetComponentsInChildren, GetComponentsInParent, and FindObjectsOfType methods. Streamlines workflow by automatically generating component lookups directly from the Inspector, reducing boilerplate code and setup time.

Automatically resets asset properties after exiting Play Mode, preventing unwanted diffs in source control. Ideal for managing runtime modifications to Materials, ScriptableObjects, and other assets that change during gameplay testing without cluttering your version control history.

Key-Value Store implementation backed by the SQLite database engine

Native Collections Stream provides Stream, TextReader, and TextWriter implementations backed by Unity's Native Collections. Use NativeList, UnsafeList, FixedList, NativeText, UnsafeText, and FixedString types as standard .NET streams for serialization, data processing, and I/O operations in performance-critical code.

Unity project for the Audio class of the SSC0770 course

Safer alternative to raw enums when used as serialized fields in Unity, maintains the right values after reordering, resistant to code merges.

A sample Unity project using a state enum ScriptableObject + MonoBehaviours with UnityEvents

Automatically generate stable ScriptableObject references to your Build Settings scenes with GUID-based tracking. Scene references update dynamically when scenes are renamed or moved, and persist across project changes without manual setup. Includes convenient utility methods for loading and unloading scenes directly from references.

Support F# scripting in Unity with automatic compilation

Audio testing project in Unity, presented in the Game Development course SCC0147 - 2017.2 at USP São Carlos.

Game made using Unity for the 1JAM - Coop (https://itch.io/jam/1jam-coop)

Unity project for UI lessons in the SSC0770 course

3D arcade game made for GBJam 8 (https://itch.io/jam/gbjam-8)

Singular provides a lightweight dependency injection and service locator framework designed to streamline object management and reduce coupling in Unity projects. It enables developers to register, resolve, and manage dependencies efficiently while maintaining clean architecture patterns across game systems and runtime components.