KOZNEO // DOCS

COSMIC ENGINE
DEVELOPER PORTAL
CORE_SYSTEMS
ENGINE_COREMEMORY_MANAGERTASK_SCHEDULER
NETWORKING
NETWORKING_SYSTEMRELAY_PROTOCOLSSYNC_STATES
GRAPHICS
SHADER_PIPELINEMATERIAL_GRAPHPOST_PROCESSING
PHYSICS
COLLISION_MATRIXFLUID_DYNAMICS
ADDONS
PLUGIN_REGISTRYHOT_RELOADING
CORE_SYSTEMSENGINE_CORE
ENGINE_CORECore engine initialization and runtime loop. Manages system lifecycle, memory pools, and thread affinity for deterministic execution.
SPEC_01 // BOOT_SEQUENCEv2.1.4_STABLE
[BOOT_LOG]
void engine_boot(engine_config* cfg) {
    // Allocate contiguous memory for real-time heap
    mem_pool_init(cfg->heap_size, MEM_FLAG_CONTIGUOUS);

    if (cfg->multithreaded) {
        thread_pool_spawn(cfg->worker_count);
        affinity_set_all(AFFINITY_CORE_HIGH);
    }

    return STATUS_READY;
}
CORE_SYSTEMSMEMORY_MANAGER
MEMORY_MANAGERDeterministic memory allocation with slab-based arenas and zero-fragmentation guarantees for real-time systems.
SPEC_01 // ARENA_ALLOCv1.8.9_STABLE
[ALLOC_TRACE]
void* arena_alloc(arena* a, size_t size) {
    if (a->offset + size > a->capacity) {
        return NULL;
    }
    void* ptr = a->base + a->offset;
    a->offset += ALIGN_UP(size, a->alignment);
    return ptr;
}
CORE_SYSTEMSTASK_SCHEDULER
TASK_SCHEDULERPriority-based job scheduler with work-stealing across worker threads. Designed for soft real-time constraints.
SPEC_01 // JOB_DISPATCHv3.2.1_STABLE
[SCHED_LOG]
void scheduler_tick(scheduler* s) {
    job* j = dequeue_high_pri(&s->queue);
    if (!j) j = steal_job(s);
    if (j) {
        j->exec(j->data);
        complete_job(j);
    }
}
NETWORKINGNETWORKING_SYSTEM
NETWORKING_SYSTEMHigh-performance UDP transport layer designed for sub-millisecond latency. Built on the Kinetic Engine core for ultra-dense data packets and real-time state synchronization.
SPEC_01 // TRANSPORT_LAYERv4.0.2_STABLE
[COPY_BUFFER]
void kinetic_init_relay(relay_config* cfg) {
    if (cfg->mode == PROTOCOL_UDP_FAST) {
        sys_mem_lock(cfg->buffer_addr, cfg->buffer_size);
        for (int i = 0; i < cfg->thread_count; ++i) {
            affinity_set(cfg->threads[i], AFFINITY_NIC);
        }
    }
}
NETWORKINGRELAY_PROTOCOLS
RELAY_PROTOCOLSDecentralized relay protocol stack with automatic failover, packet signing, and dynamic route optimization across mesh topologies.
SPEC_01 // RELAY_HANDSHAKEv2.6.3_STABLE
[HANDSHAKE_LOG]
int relay_handshake(node* a, node* b) {
    packet pkt = { .type = PKT_HANDSHAKE, .key = session_key() };
    if (send_packet(a->fd, &pkt) < 0) return ERR_LINK_FAIL;
    return await_ack(b->fd, RELAY_TIMEOUT_MS);
}
NETWORKINGSYNC_STATES
SYNC_STATESDeterministic state synchronization engine using delta-compressed snapshots and rollback networking for consistent multi-node simulation.
SPEC_01 // STATE_DELTAv1.5.7_STABLE
[SYNC_TRACE]
void sync_push_delta(sync_ctx* ctx, state_slot* slot) {
    delta d = compute_delta(ctx->baseline, slot);
    packet p = { .type = PKT_DELTA, .data = &d, .len = d.size };
    broadcast(ctx->peers, &p, ctx->peer_count);
    ctx->baseline = slot;
}
GRAPHICSSHADER_PIPELINE
SHADER_PIPELINEMulti-pass shader compilation pipeline with hot-reloading support. Optimized for Vulkan and DirectX 12 backends.
SPEC_01 // COMPILATIONv5.0.1_STABLE
[COMPILE_LOG]
void shader_compile(shader_src* src, shader_blob* out) {
    spirv_cross_init(&src->hlsl);
    if (src->optimize) spirv_optimize(&src->ir);
    out->bytecode = spirv_finalize(&src->ir, &out->size);
}
GRAPHICSMATERIAL_GRAPH
MATERIAL_GRAPHNode-based material authoring graph with real-time preview. Supports PBR, NPR, and custom shading models.
SPEC_01 // NODE_GRAPHv2.3.8_STABLE
[GRAPH_EVAL]
void material_eval(mat_graph* g, mat_output* out) {
    for (int i = 0; i < g->node_count; i++) {
        node_exec(g->nodes[i]);
    }
    out->albedo = sample_output(g, NODE_ALBEDO);
    out->normal = sample_output(g, NODE_NORMAL);
}
GRAPHICSPOST_PROCESSING
POST_PROCESSINGFull-screen post-processing stack with bloom, tone-mapping, chromatic aberration, and temporal anti-aliasing.
SPEC_01 // EFFECT_STACKv3.1.2_STABLE
[FX_TRACE]
void post_process(frame_buffer* fb, post_effects* fx) {
    if (fx->bloom) apply_bloom(fb, fx->bloom_intensity);
    if (fx->taa) apply_taa(fb, fx->taa_samples);
    apply_tone_map(fb, fx->exposure);
}
PHYSICSCOLLISION_MATRIX
COLLISION_MATRIXBroad-phase and narrow-phase collision detection using spatial hashing and GJK-EPA for convex hull intersection tests.
SPEC_01 // BROAD_PHASEv2.0.4_STABLE
[COLLIDE_LOG]
void broad_phase(collision_world* w) {
    hash_grid_clear(&w->grid);
    for (int i = 0; i < w->body_count; i++) {
        hash_grid_insert(&w->grid, &w->bodies[i]);
    }
}
PHYSICSFLUID_DYNAMICS
FLUID_DYNAMICSSPH-based fluid simulation with adaptive particle density and GPU compute shader acceleration for real-time interaction.
SPEC_01 // SPH_SOLVERv1.9.5_STABLE
[FLUID_LOG]
void sph_step(sph_solver* s, float dt) {
    for (int i = 0; i < s->particle_count; i++) {
        float dens = compute_density(&s->particles[i], s);
        float press = compute_pressure(dens, s->rest_density);
        apply_forces(&s->particles[i], press, dt);
    }
}
ADDONSPLUGIN_REGISTRY
PLUGIN_REGISTRYDynamic shared library loader with versioned symbol resolution and sandboxed execution contexts for third-party plugins.
SPEC_01 // PLUGIN_LOADv1.2.7_STABLE
[LOAD_TRACE]
void* plugin_load(const char* path) {
    plugin_handle* h = dl_open(path);
    if (!h) return NULL;
    plugin_api* api = dlsym(h, "PLUGIN_API");
    return registry_register(h, api);
}
ADDONSHOT_RELOADING
HOT_RELOADINGReal-time asset and code hot-reloading with dependency graph tracking. Minimal interruption — only affected modules are recycled.
SPEC_01 // WATCHERv1.6.2_STABLE
[WATCHER_LOG]
void hot_reload_tick(watcher* w) {
    for (int i = 0; i < w->file_count; i++) {
        if (file_changed(&w->files[i])) {
            module_reload(w->files[i].module_id);
        }
    }
}