How to Configure Flow Settings and Always Included Assemblies in Ceres Project Settings

Configure Flow Settings and Always Included Assemblies in Ceres by navigating to Project → Ceres → Flow Settings in the Unity Editor, where you can toggle executable reflection logging and define wildcard patterns for assemblies that must always be scanned.

The Ceres Unity framework provides a dedicated Project Settings Provider to manage Flow system configuration without hardcoding values. This article explains how to configure Flow Settings and Always Included Assemblies in Project Settings using both the Unity Editor interface and programmatic APIs, based on the actual implementation in the akikurisu/ceres repository.

Understanding Flow Settings in Ceres

The Flow Settings system controls how Ceres discovers and reflects upon executable members in your Unity project. The configuration is split between editor-time settings and runtime configuration, bridged through the FlowSettings singleton.

Executable Reflection Logging

The Executable Reflection log setting toggles verbose diagnostic output during the reflection process. When enabled, Ceres logs detailed information about which members are being discovered and processed in Flow graphs. This value is stored in FlowSettings.logExecutableReflection and copied to FlowConfig.logExecutableReflection on save.

Always Included Assembly Wildcards

The Always Included Assembly Wildcards setting defines which assemblies are forcibly included in the reflection scan, regardless of whether they contain Flow-related types. This prevents the system from skipping third-party runtime DLLs or custom assemblies that don't directly reference Ceres but contain methods you want to expose in Flow graphs.

How to Configure Flow Settings in the Unity Editor

To configure Flow Settings and Always Included Assemblies in Project Settings through the Unity interface:

1. Open the Unity Editor and navigate to Edit → Project Settings.
2. In the left sidebar, locate Ceres → Flow Settings.
3. The Flow Settings Provider window displays two configurable properties:
   • Always Included Assembly Wildcards: A list of wildcard strings
   • Executable Reflection log: A boolean toggle

When you modify these values, the FlowSettingsProvider automatically handles persistence through SerializedObject.ApplyModifiedPropertiesWithoutUndo(). If changes are detected, the provider invokes FlowSettings.SaveSettings(), which writes the singleton instance to disk and synchronizes the values to the runtime FlowConfig class.

Configuring Always Included Assembly Wildcards

Wildcard patterns use standard glob syntax where * matches any sequence of characters. Internally, Ceres converts these patterns to regular expressions by anchoring them with ^ and $ and escaping special regex characters.

Default Wildcards

The FlowConfig.DefaultIncludedAssemblyWildcards property defines the following default patterns:

• Unity.*
• UnityEngine
• UnityEngine.*

These ensure that all Unity core assemblies are scanned for executable members.

Adding Custom Wildcards

To include third-party or custom assemblies, add wildcard entries such as:

• MyCompany.* (includes all assemblies starting with "MyCompany")
• ThirdPartyLib (includes a specific assembly exactly named "ThirdPartyLib")
• Runtime.* (includes all assemblies in the "Runtime" namespace group)

Programmatic Configuration Examples

Opening the Settings UI Programmatically

You can open the Flow Settings window from custom editor scripts:

// Open the Ceres Flow Settings panel directly
UnityEditor.SettingsService.OpenProjectSettings("Project/Ceres/Flow Settings");

Adding Wildcards via Editor Script

To programmatically configure Flow Settings and Always Included Assemblies in Project Settings:

using Ceres.Editor;
using System.Collections.Generic;
using UnityEditor;

public static class FlowSettingsUtility
{
    [MenuItem("Ceres/Flow/Add MyAssembly Wildcard")]
    public static void AddMyWildcard()
    {
        var settings = FlowSettings.Instance;
        var list = settings.alwaysIncludedAssemblyWildcards?.ToList() ?? new List<string>();
        
        if (!list.Contains("MyCompany.*"))
        {
            list.Add("MyCompany.*");
            settings.alwaysIncludedAssemblyWildcards = list.ToArray();
            FlowSettings.SaveSettings(); // Forces immediate persistence to FlowConfig
        }
    }
}

Verifying Assembly Inclusion at Runtime

Check whether a specific assembly will be included in the Flow reflection scan:

using System.Reflection;
using Ceres.Graph.Flow;
using UnityEngine;

public class AssemblyCheck : MonoBehaviour
{
    void Awake()
    {
        var asm = Assembly.GetExecutingAssembly();
        bool isIncluded = FlowConfig.IsIncludedAssembly(asm);
        Debug.Log($"{asm.GetName().Name} included? {isIncluded}");
    }
}

Summary

• Navigate to Project → Ceres → Flow Settings in the Unity Editor to configure Flow Settings and Always Included Assemblies in Project Settings.
• Always Included Assembly Wildcards uses * glob patterns to force specific assemblies into the reflection scan, preventing Ceres from skipping third-party DLLs.
• Changes are persisted through FlowSettings.SaveSettings(), which synchronizes editor settings to the runtime FlowConfig class.
• Default wildcards include Unity.*, UnityEngine, and UnityEngine.* to ensure Unity core assemblies are always scanned.

Frequently Asked Questions

How do I access Flow Settings if I don't see the Ceres menu in Project Settings?

Ensure that the Ceres package is properly installed and that the Ceres.Editor namespace is available. The Flow Settings provider is registered automatically when the editor scripts compile. If the menu is missing, check the Console for compilation errors or missing assembly references.

What is the difference between FlowSettings and FlowConfig?

FlowSettings is an editor-only singleton that manages the UI and serialization of project preferences. FlowConfig is the runtime configuration class that actually stores the values used during play mode. When you save settings in the editor, FlowSettings.SaveSettings() copies the values from the editor singleton to the runtime FlowConfig to ensure consistency.

Can I use regular expressions instead of wildcards for assembly matching?

No, the UI accepts only glob-style wildcards where * matches any sequence of characters. However, these wildcards are internally converted to regular expressions by FlowConfig. If you need complex matching, you would need to modify the source code in Runtime/Flow/Models/FlowConfig.cs where the regex conversion occurs.

Why are my third-party assemblies not being discovered even after adding wildcards?

Verify that the wildcard pattern actually matches the assembly name (not the file name). Use the FlowConfig.IsIncludedAssembly() method at runtime to debug. Also ensure that the assemblies are not being stripped by Unity's code stripping settings, as Ceres relies on reflection that may be affected by aggressive stripping in release builds.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}