Your code,
in the loop.

/* Slew-rate limiter: the output chases u[0]
   at no more than 2 units/s. */
void compute(double t, const ICoreCMatrix* u, int uCount,
             ICoreCMatrix* y, int yCount) {
    /* statics persist between steps, reset every run */
    static double last = 0.0, tPrev = 0.0;
    (void)uCount; (void)yCount;
    double step = 2.0 * (t - tPrev);
    double d = ICORE_AT(u[0], 0, 0) - last;
    if (d >  step) d =  step;
    if (d < -step) d = -step;
    last += d;
    tPrev = t;
    y[0].rows = 1;
    y[0].cols = 1;
    ICORE_AT(y[0], 0, 0) = last;
}

import numpy as np

def compute(t, u, state):
    # Slew-rate limiter: the output chases u[0]
    # at no more than 2 units/s.
    last = state.get("last", 0.0)
    step = 2.0 * (t - state.get("t", 0.0))
    d = float(np.clip(u[0][0, 0] - last, -step, step))
    state["last"], state["t"] = last + d, t
    return [np.array([[last + d]])]

One limiter written twice, once for each block. A unit step arrives at 0.5 s, and each lane's compute() is called once per 0.1 s sample: one dot per call. For this page, the C body was compiled against the block's own prelude and the Python body run with numpy, and the two agree at every sample. State lives in a C static or in Python's state dict, and both are reset at every simulation start.

One function. That's the whole API.

Each block calls a single compute() of yours. Everything it needs arrives as arguments, and everything it produces goes out through the output ports.

Both blocks start with one input and one output, and you can change both counts. Every port is a double unless you retype it, and the new type reaches your code without anything extra to declare.

A block like any other.

Once it's on the canvas, the solver treats your code the way it treats a library block.

Exports to its own language. Nowhere it would break.

Hand-written C can't be translated mechanically, and none of the other targets can carry a Python interpreter. So each block exports to the one language it's written in, and refuses the other nine by name rather than emitting code that won't run.

If a subsystem has to reach an FPGA, keep hand-written code out of that subtree. Or, once the code settles, promote it to a real block with its own code for every target. That's what the Block Wizard is for.