For these notes, I'm assuming the reader is reasonably familiar with how cython, python and godot works.

Basic steps to use cython in your godot project:

• Download and install godot-python and make sure python scripts are working in your project:
  • https://github.com/touilleMan/godot-python
• Install Cython in your python environment:
  • cd myproject
  • ./addons/pythonscript/x11-64/bin/python3 -m pip install cython==3.0a5
  • (substitute x11-64 above for your platform)
• copy the godot_headers folder to your project (I'd recommend cloning godot-python, initializing the godot-header submodule and copying it verbating, to make sure we are using the same version as godot-python)
• create cython modules (pyx, pyd, etc)
• create a setup.py making sure to pass the godot_headers path. e.g:

if __name__ == '__main__':
    from setuptools import setup, Extension
    from Cython.Build import cythonize
    from Cython.Compiler import Options
    CFLAGS = ["-O0"]
    Options.cimport_from_pyx = True
    setup(
        ext_modules=cythonize(
            [
                Extension(
                    "my_ext_name",
                    sources=["my_pyx_file.pyx"],
                    include_dirs=["godot_headers"],
                    extra_compile_args=CFLAGS
                ),
            ],
            compiler_directives={'language_level': "3"}
        )
        
    )

• refer to cython docs if you're not sure how to create and compile cython modules.
• run your setup.py to compile the extension and now you should be able to import it from your python code in godot.

NOTE: I have not tried to inherit from Node or some other godot class, that may be possible, but I'm not sure. If you try it and succeed make sure to leave a comment here!

Using GDNative from cython:

godot-python already has all the gdnative bindings compiled for you, and all the pxd's necessary are provided in your installation of godot-python, so all you need to do is include the godot-headers.

Examples:

#cython: cdivision=True
cimport cython
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
from libc.math cimport fmod, sqrt, pow, modf, sin, cos
from cpython cimport array
from godot import OpenSimplexNoise
from godot.bindings cimport Object
from godot._hazmat.gdnative_api_struct cimport *
from godot._hazmat.gdapi cimport pythonscript_gdapi10 as gdapi10

cdef godot_method_bind *mbind_noise_3d = gdapi10.godot_method_bind_get_method("OpenSimplexNoise", "get_noise_3d")
cdef godot_method_bind *mbind_noise_2d = gdapi10.godot_method_bind_get_method("OpenSimplexNoise", "get_noise_2d")

@cython.cdivision(True)
cdef inline unsigned int simple_hash_function(unsigned int seed) nogil:
    cdef unsigned int a = seed
    a = (a ^ 61) ^ (a >> 16)
    a = a + (a << 3)
    a = a ^ (a >> 4)
    a = a * 0x27d4eb2d
    a = a ^ (a >> 15)
    return a

@cython.cdivision(True)
cdef inline simple_hash_function_normalized(unsigned int seed) nogil:
    return (<double>det_rand(seed)) / 0xFFFFFFFE

@cython.cdivision(True)
cdef inline unsigned long fibonacci_hash(unsigned long seed, unsigned char bits) nogil:
    cdef unsigned char shift_amount = (64 - bits);
    seed ^= seed >> shift_amount
    return (seed * 11400714819323198485llu) >> shift_amount

@cython.cdivision(True)
cdef inline double normalized_fibonacci_hash(unsigned long seed, unsigned char bits) nogil:
    return (<double>fibonacci_hash(seed, bits)) / <double>(2 ** (64 - bits))

@cython.cdivision(True)
cdef void normalize_vector3(double* out) nogil:
    cdef double lenvec = sqrt((out[0] * out[0]) + (out[1] * out[1]) + (out[2] * out[2]))
    if lenvec > 0.0:
        out[0] = out[0] / lenvec
        out[1] = out[1] / lenvec
        out[2] = out[2] / lenvec

@cython.final
cdef class MyCdefClass:
    def __cinit__(self, int xa, int xb, int ya, int yb, int za, int zb):
        self.xa = xa
        self.xb = xb
        self.ya = ya
        self.yb = yb
        self.za = za
        self.zb = zb
        self.lx = xb - xa
        self.ly = yb - ya
        self.lz = zb - za
        self.size = self.lx * self.ly * self.lz
        # TODO: switch those to a hashtable for better memory utilization (numpy sparse array)
        self.myarray_ptr = <double*>malloc(self.size * sizeof(double))
        self.myarray = <double[:self.lx, :self.ly, :self.lz:1]>(self.myarray_ptr)
        self.noise = OpenSimplexNoise()
        self.noise_ptr = (<Object>self.noise)._gd_ptr

    def __dealloc__(self):
        if self.myarray_ptr != NULL:
            free(self.myarray_ptr)
        self.myarray_ptr = NULL

    @cython.boundscheck(False)
    @cython.initializedcheck(False)
    cdef double fill_array(self, int xmax, int ymax, int zmax):
        cdef double density = 0
        cdef double n2
        cdef const void *args[3]
        cdef double x_d, y_d, z_d
        for x in range(0, xmax):
            for y in range(0, ymax):
                for z in range(0, zmax):
                    # make sure parameters are actually a double, or ptrcall will not work correctly
                    x_d = <double>x
                    y_d = <double>y
                    z_d = <double>z
                    args[0] = &x_d
                    args[1] = &y_d
                    args[2] = &z_d

                    # density = noise3d(x, y, z)
                    gdapi10.godot_method_bind_ptrcall(mbind_noise_3d, self.ptr, args, &density)
                    # remap to 0..1 range
                    density = (density + 1) / 2.0
                    self.myarray[x, y, z] = density
1
    @cython.boundscheck(False)
    @cython.initializedcheck(False)
    cdef double sample_array(self, int x, int y, int z) nogil:
        return self.myarray[x, y, z]

    

Using C++ in your cython module

godot-header and godot-python cacn work with C++ with a couple of changes:

• make sure your module is being compiled with C++:

Extension(
        modname,
        sources=[pyxfilename],
        include_dirs=INCLUDE_PATHS,
        libraries=LIBS,
        library_dirs=LIBDIRS,
        extra_compile_args=CFLAGS,
        language='c++'
    )

• If you try to import GDNative, you will have ABI errors. to resolve it, use the gdcpp.pxd file included in this gist, and instead of importing the gdnative api with from godot._hazmat.gdapi cimport pythonscript_gdapi10 as gdapi10, use from cppgd cimport *
• the cppgd.pxd file is basically the same as godot-python's own, except using extern "C" Examples:

cimport cython
from libcpp.unordered_map cimport unordered_map
from libcpp.list cimport list
from libcpp.utility cimport pair
from libcpp.vector cimport vector
from libc.math cimport round
from libc.stdlib cimport malloc, free
from libc.stdio cimport printf
from cython.operator cimport dereference, postincrement

from worldgen.cppgd cimport *


ctypedef unordered_map[uint64_t, Vertex*] vtx_map

cdef unordered_map[uint64_t, local_data] thread_local_data

cdef class MyCdefClass:

    def __cinit__(self):
        pass

    def __dealloc__(self):
        pass

    def __init__(self, _tolerance):
      pass

    cdef void some_method(self, double x, double y, double z) nogil:
        cdef uint64_t key = x + y + z

    @cython.cdivision(True)
    cdef void copy_vertices_to_godot(self, void* _vtx_array_data, void* _normal_array_data) nogil:
        cdef godot_pool_vector3_array* vtx_array_data = <godot_pool_vector3_array*>_vtx_array_data
        cdef godot_pool_vector3_array* normal_array_data = <godot_pool_vector3_array*>_normal_array_data
        pythonscript_gdapi10.godot_pool_vector3_array_resize(vtx_array_data, self._vtx_len)
        pythonscript_gdapi10.godot_pool_vector3_array_resize(normal_array_data, self._vtx_len)
        cdef int i = 0
        cdef int used_vertices = 0
        cdef godot_vector3 gd_vtx
        cdef godot_vector3 gd_norm
        for i in range(self._vtx_len):
            v = self.t_local_data.vertex_list[i]
            v.x /= v.dupecount
            v.y /= v.dupecount
            v.z /= v.dupecount
            v.normalx /= v.dupecount
            v.normaly /= v.dupecount
            v.normalz /= v.dupecount
            pythonscript_gdapi10.godot_vector3_new(&gd_vtx, v.x, v.y, v.z)
            pythonscript_gdapi10.godot_pool_vector3_array_set(vtx_array_data, i, &gd_vtx)

            pythonscript_gdapi10.godot_vector3_new(&gd_norm, v.normalx, v.normaly, v.normalz)
            pythonscript_gdapi10.godot_pool_vector3_array_set(normal_array_data, i, &gd_norm)
            used_vertices += 1
            free(v)

        pythonscript_gdapi10.godot_pool_vector3_array_resize(vtx_array_data, used_vertices)
        pythonscript_gdapi10.godot_pool_vector3_array_resize(normal_array_data, used_vertices)