What Is the Default Universe Configuration Provided by MulleObjC-startup?

MulleObjC-startup provides the default universe configuration by copying the global runtime defaults from mulle_objc_global_get_default_universeconfiguration(), which disables debug output, uses standard memory allocation, and sets no custom callbacks unless explicitly modified.

MulleObjC-startup acts as the bootstrap layer for the Mulle Objective-C runtime, responsible for initializing the first universe your application executes within. When launching a MulleObjC program, the startup module retrieves the default universe configuration from the underlying MulleObjC runtime library and passes it directly to the universe creation routine. This configuration structure, defined in MulleObjC/mulle-objc-universeconfiguration.h, controls critical runtime behaviors including memory allocation strategies, exception handling, and debug output settings.

Default Configuration Source in the MulleObjC Runtime

The MulleObjC-startup repository does not hard-code its own universe configuration values. Instead, it delegates to the global default configuration defined in the external MulleObjC library. In src/MulleObjC-startup.m, the startup routine calls mulle_objc_global_get_default_universeconfiguration() to obtain a pointer to the runtime's default configuration structure.

This function returns a struct _mulle_objc_universeconfiguration that is initialized once by the runtime in MulleObjC/mulle-objc-universeconfiguration.c. The startup code then copies this structure into a local variable before passing it to MulleObjCBang, which creates the initial universe.

Structure of the Default Universe Configuration

The default configuration is encapsulated in struct _mulle_objc_universeconfiguration, declared in MulleObjC/mulle-objc-universeconfiguration.h. This structure contains function pointers for callbacks, memory allocator references, version identifiers, and runtime option flags.

Key fields include:

• debug – Controls runtime debug output verbosity
• exception_handler – Pointer to the exception handling routine
• class_load_callback – Hook invoked when a class is loaded
• class_initialize_callback – Hook invoked during class initialization
• allocator – Memory allocator used for universe allocations
• object_set_dealloc_callback – Hook for object deallocation
• runtime_options – Bitmask of runtime behavior flags
• objc_runtime_version – Version compatibility identifier

Default Values for Key Configuration Fields

Debug and Runtime Options

By default, the configuration disables debug output. The debug field is set to 0, and runtime_options is set to MULLE_OBJC_RUNTIME_DEFAULT. This provides a production-ready runtime environment without tracing or verbose logging.

Memory Allocation

The default allocator is &mulle_std_allocator, which uses the standard C library memory management functions. This ensures compatibility with standard system allocators while allowing advanced users to substitute custom allocators for specialized memory tracking or garbage collection schemes.

Callback Hooks

All callback function pointers default to NULL except for exception_handler, which points to &MulleObjCDefaultExceptionHandler. This means:

• No custom class load notifications (class_load_callback is NULL)
• No custom initialization hooks (class_initialize_callback is NULL)
• No custom deallocation tracking (object_set_dealloc_callback is NULL)
• Standard exception handling is active

Version Compatibility

The objc_runtime_version field is set to MULLE_OBJC_RUNTIME_VERSION, ensuring the universe uses the current runtime ABI and feature set.

How MulleObjC-startup Applies the Configuration

In src/MulleObjC-startup.m, the startup routine implements a bang function that prepares the universe configuration before creation. The code explicitly copies the global default configuration into a local stack variable:

static void bang(struct _mulle_objc_universe *universe,
                 struct mulle_allocator *allocator,
                 void *userinfo)
{
    struct _mulle_objc_universeconfiguration config;

    memcpy(&config,
           mulle_objc_global_get_default_universeconfiguration(),
           sizeof(config));

    /* Create the universe with the default configuration */
    MulleObjCBang(universe, allocator, &config);
}

This pattern ensures that the startup module does not maintain duplicate default values, but rather references the canonical defaults defined in the MulleObjC runtime library. The MulleObjCBang function then consumes this configuration to initialize the universe's internal state, including setting up the class table, selector table, and memory pools according to the specified parameters.

Customizing the Default Universe Configuration

While MulleObjC-startup uses the runtime defaults unchanged, applications can override these settings after startup or by modifying the configuration before universe creation. To customize, you retrieve the default configuration pointer and modify specific fields before the universe is initialized:

void my_custom_init(void)
{
    struct _mulle_objc_universeconfiguration *cfg;

    cfg = mulle_objc_global_get_default_universeconfiguration();
    cfg->debug = 1;               // enable debug output
    cfg->exception_handler = &my_handler; // install custom exception handler
    cfg->allocator = &my_custom_allocator; // use custom memory management
}

Note that modifying the global default configuration affects all future universes created in the process. For per-universe customization, copy the defaults into a local structure as the startup code does, then modify the local copy before passing it to MulleObjCBang.

Summary

• MulleObjC-startup does not define its own universe configuration values; it retrieves them from the MulleObjC runtime via mulle_objc_global_get_default_universeconfiguration().
• The default configuration disables debug output (debug = 0), uses standard memory allocation (&mulle_std_allocator), and sets only the default exception handler.
• All callback hooks (class_load_callback, class_initialize_callback, object_set_dealloc_callback) default to NULL, indicating no custom runtime interception.
• The startup code in src/MulleObjC-startup.m copies this global configuration into a local variable and passes it to MulleObjCBang to create the initial universe.
• Applications can override defaults by modifying the global configuration pointer or by providing a customized local copy before universe creation.

Frequently Asked Questions

Where is the default universe configuration defined in the source code?

The default universe configuration is defined in the MulleObjC runtime library, specifically in MulleObjC/mulle-objc-universeconfiguration.c and declared in MulleObjC/mulle-objc-universeconfiguration.h. MulleObjC-startup only consumes this configuration via the mulle_objc_global_get_default_universeconfiguration() function in src/MulleObjC-startup.m.

Can I change the default configuration without modifying the MulleObjC-startup source?

Yes. You can retrieve the global default configuration pointer using mulle_objc_global_get_default_universeconfiguration() and modify its fields before any universe is created. Alternatively, you can implement your own startup logic that copies the defaults into a local structure, modifies the local copy, and passes it to MulleObjCBang instead of using the stock startup routine.

What happens if I set the debug field to a non-zero value?

Setting the debug field to a non-zero value enables runtime debug output. This typically causes the MulleObjC runtime to print diagnostic information about class loading, method caching, and universe state transitions to stderr. While useful for debugging runtime issues, this should be disabled in production builds to avoid performance overhead and log spam.

Does MulleObjC-startup support multiple universe configurations simultaneously?

MulleObjC-startup itself initializes only the first (root) universe using the default configuration. However, the MulleObjC runtime supports multiple universes. To create additional universes with different configurations, you would manually call MulleObjCBang or the appropriate universe creation API with a custom struct _mulle_objc_universeconfiguration, rather than relying on the startup module's automatic initialization.

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