Scylla Core

Scylla is a modular game framework for Unity. Its modules and tools are built to work together, from fundamental layers like events and data structures to specialized systems like user input, camera controls and character controls, and further up to systems for specific game genres. Scylla Core is the basis every other Scylla module builds on, and it is just as useful on its own.

===== FEATURES =====

• A module system with deterministic, tiered initialization order, automatic dependency resolution, and fail-fast validation. Every Scylla module uses it, and it can be used to create custom modules.

• A strongly-typed event system with priority ordering and cancellation. Subscriptions are lifecycle-safe and clean up automatically when their Unity objects are destroyed.

• A centralized debug logger with category tagging, pluggable log receivers (Unity console and log files are included), and a configurable log level.

• A time system with pause and time-scale control, a deterministic time mode for replays and tests, calendar math, a tick scheduler, and time-scale modifiers.

• A scene manager that keeps the framework alive across scene loads and handles managed scene loading: single or additive, awaitable operations with progress and lifecycle events, optional Addressables-based scenes, and automatic cleanup of in-flight tweens, time-scale modifiers and event subscribers between scenes.

• A collection of high-performance data structures: priority queue, deque, ring buffer, type map, bit array, disjoint set, object pool and trie. Spatial structures: quadtree, octree, BVH, KD-tree and loose variants. Graphs with traversal, minimum spanning tree, shortest path and connected components. Grid systems for square, hex and triangle layouts. Burst- and DOTS-compatible variants are included.

• An extensive utility library:

Math: approximate float comparison, interpolation, complex numbers, polynomials and more.

Procedural, deterministic noise: 6 algorithms (OpenSimplex2, Perlin, Value, Value Cubic, Cellular, Pixel) plus fractals, domain warping and curl fields.

Deterministic random numbers: 5 interchangeable algorithms (PCG32, Xoshiro256, Mersenne Twister, SplitMix64, Xoroshiro128+), dice rolls, Poisson disk sampling, and seeded text and ID generation.

Tweening: a complete tween system with all standard easings, sequences, pooling, and support for transforms, materials, audio sources, canvas groups, sprite renderers and UI rect transforms.

Serialization: an attribute-based serializer with reference tracking, polymorphism and version migration.

Compression: GZip, Deflate, BZip2 and Zip archives (BZip2 and Zip need the optional SharpZipLib package).

Cryptography: AES-CBC-HMAC, AES-GCM, ChaCha20-Poly1305 and PBKDF2 key derivation.

Checksums: Adler32, CRC16, CRC32, Fletcher32, XXHash32 and XXHash64.

Files: path resolution, config files and image file input and output.

Procedural map generation: 9 algorithms (BSP, Cellular Automata, Drunkard Walk, Maze, Maze with Rooms, Room and Corridor, Voronoi Regions, Noise Threshold, Floorplan) on square, hex and triangle grids, with L-shaped and winding corridors and post-processing for connectivity, dead-end removal, room detection, and door and spawn placement.

Debug drawing: immediate-mode debug drawing of 2D and 3D shapes in world or screen space, such as lines, polylines, circles, ellipses, rectangles and regular polygons, drawn for one frame or for a set time. It needs no setup and batches everything into one mesh per frame.

Geometry: geometric primitives (bounding boxes, spheres, capsules, ellipses, 2D and 3D sizes) plus a runtime library of more than 40 parametric meshes, from boxes, spheres, cylinders, cones, rings and pyramids to level-building pieces like stairs, walls and simple props, with colliders and palette-driven face colors.

UI: runtime UI scaffolding with DPI scaling, layer helpers, canvas creation and screen-space hit testing, a declarative layout system (horizontal, vertical and layered stacks, grids, adaptive and flex stacks, spacers, insets and aspect-ratio breakpoints), and efficient scrollable text areas.

Addressables: an optional wrapper over Unity Addressables for loading, instantiation, scene loading and unloading, batch loads by label or key, dependency downloads and catalog updates, with async and await support, cancellation, typed errors and handles that release their assets automatically.

Many more everyday helpers for colors, strings, fonts, collections, types and more.

• Color palettes and color gradients that can be looked up by name or tag at runtime and edited with Scylla Chroma.

• Unit types with automatic conversion for area, length, data size, temperature, time and more.

• Plenty of demos, all with well-documented source code.

===== QUALITY & PERFORMANCE PRINCIPLES =====

• Zero allocations in framework hot paths.

• No implicit Update loops in Core.

• Object pooling built in: generic pools, Unity object pools, tween pools and string builder pools. Pooling is the default pattern across the framework.

• Precompiled property accessors in the serializer. Reflection cost is paid once per type, not on every read or write.

• Thread-safe metadata caches with lazy, double-checked initialization.

• Burst- and DOTS-compatible variants of the major data structures for use inside Burst-compiled jobs.

• Fail-fast startup. An invalid dependency graph stops initialization cleanly instead of running half-broken in production.

• Deterministic module initialization order. The same dependency graph initializes the same way on every run, which replays, deterministic tests and frame-exact debugging depend on.

• Domain-reload-safe. Static state and caches reset correctly across Play mode transitions, including with Enter Play Mode options enabled.

• Cache-friendly memory layouts, with value-type structs on the hot paths.

• Self-contained. No dependencies on other paid assets. Built only on standard Unity packages; optional features such as Addressables and BZip2 or Zip compression switch on when their package is installed and stay out of the build when it is not.

• Built for modern Unity (6.5 and later) using current APIs throughout, with no deprecated calls and no compatibility code for older versions.

• Thoroughly tested, with more than 12,000 automated tests.

• Warning-free. Compiler and code inspection warnings are fixed as part of every release.

===== OTHER SCYLLA MODULES & TOOLS =====

• Scylla Input
• Scylla Chroma
• Scylla Graphics (coming soon)
• Scylla Console (coming soon)
• Scylla TextMode (coming soon)
• Check the complete project roadmap here.

===== LINKS =====

Official Site & Documentation

API Documentation

Discord