Dynamic Block not rendering in frontend

[Der-Alex]

Hi there. I created a dynamic block using the create-block script:
npx @wordpress/create-block@latest --namespace my-namespace --no-plugin my-block --variant dynamic
This creates a my-block folder inside my theme's assets/blocks folder.

In my theme's functions.php I register all my blocks like so:

function my_namespace_blocks_init() {
    $directory = __DIR__ . '/assets/blocks';
        
    // get all subfolders inside assets/blocks
    $scanned_directory = array_diff( scandir( $directory ), array( '..', '.' ) );

    foreach ( $scanned_directory as $dir ) {
        register_block_type(
	    $directory . '/' . $dir,
	    array(
		'render_callback' => 'my_namespace_render',
	    )
	);
    }
}
add_action( 'init', 'my_namespace_blocks_init' );

My block's render.php file looks like this:

<?php
function my_namespace_render( $attr ) {
	return '<p>Hello worlds!</p>';
}

For testing purposes I left the other files as they were created by the script. In the full site editor the "My Block" block is available and can be added to the page and gets rendered in the backend. But nothing gets rendered in the frontend. I tested if the render.php gets loaded and changed the content to basic html:

<p>Hello worlds!</p>

This works. I also tried to echo and die inside the render callback function. The callback function simply doesn't get called. I double checked that the callback function name is correct.

Is there anything missing to make the render callback function work? Thanks in advance.

EDIT:

Calling the render callback function inside register_block_type function directly works as well:

        register_block_type(
	    $directory . '/' . $dir,
	    array(
		'render_callback' => function() { return "<p>Hi!</p>"; },
	    )
	);
	...

[Der-Alex]

Okay it seems that the render.php file gets loaded or included after register_block_type is called. So having the callback function inside the render.php file cannot work. When I add include_once $directory . '/' . $dir . '/render.php'; the callback function would work but doing this feels wrong.

Is it a known bug that you cannot use the callback function inside the render.php file?

[s-a-s-k-i-a]

You've actually self-diagnosed it correctly — the reason is in how block.json's render field is implemented in core. Looking at wp-includes/blocks.php, when register_block_type_from_metadata() sees a render field in block.json, it doesn't call a function — it generates an internal render_callback that does:

ob_start();
require $template_path;
return ob_get_clean();

So render.php is expected to output HTML directly (echo / inline markup / function call). It's not a place to define a function — anything just defined there gets loaded at render time and discarded.

On top of that you're also passing 'render_callback' => 'my_namespace_render' to register_block_type() as a string reference. At init time when registration runs, my_namespace_render isn't defined yet (render.php hasn't been required), so is_callable( $this->render_callback ) returns false → WP_Block_Type::is_dynamic() returns false → core never invokes the callback. That's why your inline anonymous-function version worked: the callable was resolvable at registration time.

Three clean ways forward, pick one:

A. Drop the render_callback arg and let block.json's render field do the work:

register_block_type( $directory . '/' . $dir );  // no second arg

render.php:

<?php
// $attributes, $content, $block are available here.
?>
<p>Hello worlds!</p>

B. Keep render_callback in PHP, define the function at init (i.e. in functions.php or a file require'd from it before registration runs):

function my_namespace_render( $attributes, $content, $block ) {
    return '<p>Hello worlds!</p>';
}

function my_namespace_blocks_init() {
    // … register_block_type with 'render_callback' => 'my_namespace_render'
}
add_action( 'init', 'my_namespace_blocks_init' );

C. Anonymous-function variant, which is what worked for you — perfectly fine if all you need is a small piece of render logic and you don't want a separate file.

Mixing block.json's render and PHP-side render_callback is the original trap: when both are set, the PHP-args one wins (it's merged in last), and if it's an unresolvable string, the block silently becomes non-dynamic. Not a bug per se, but a sharp edge worth flagging in the docs.