fastpython-native 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

fastpython/__init__.py

@@ -1,7 +1,9 @@
 from .api import compile_native, accelerate, AcceleratedFunction
+from .jit import jit
 from .hardware.cpu import get_cpu_info, CPUFeatures
 from .importer import auto_accelerate
 from .server import FastWebServer
+from .memory import BumpArena, allocate, AlignedBuffer
 from . import simd
 from . import memory
 
@@ -9,10 +11,14 @@ __all__ = [
     "compile_native",
     "accelerate",
     "AcceleratedFunction",
+    "jit",
     "get_cpu_info",
     "CPUFeatures",
     "auto_accelerate",
     "FastWebServer",
+    "BumpArena",
+    "allocate",
+    "AlignedBuffer",
     "simd",
     "memory",
 ]

fastpython/accelerators/fast_raytracer.c

@@ -0,0 +1,301 @@
+#include <Python.h>
+#include <math.h>
+#include <stdlib.h>
+#include <omp.h>
+
+typedef struct {
+    double ax, ay, az;
+    double bx, by, bz;
+    double cx, cy, cz;
+    double nx, ny, nz;
+    double ka_r, ka_g, ka_b;
+    double kd_r, kd_g, kd_b;
+    double ks_r, ks_g, ks_b;
+    double shininess;
+} NativeFace;
+
+typedef struct {
+    double x, y, z;
+    double amb_r, amb_g, amb_b;
+    double diff_r, diff_g, diff_b;
+    double spec_r, spec_g, spec_b;
+} NativeLight;
+
+static inline double clamp01(double v) {
+    if (v < 0.0) return 0.0;
+    if (v > 1.0) return 1.0;
+    return v;
+}
+
+// Ray-triangle intersection test using Cramer's rule
+static inline int intersect_triangle(
+    const NativeFace* face,
+    double ox, double oy, double oz,
+    double dx, double dy, double dz,
+    double* out_t,
+    double* out_hx, double* out_hy, double* out_hz
+) {
+    double m11 = face->bx - face->ax;
+    double m12 = face->cx - face->ax;
+    double m13 = -dx;
+    double m21 = face->by - face->ay;
+    double m22 = face->cy - face->ay;
+    double m23 = -dy;
+    double m31 = face->bz - face->az;
+    double m32 = face->cz - face->az;
+    double m33 = -dz;
+
+    double det_A = m11*(m22*m33 - m23*m32) - m12*(m21*m33 - m23*m31) + m13*(m21*m32 - m22*m31);
+    if (det_A > -1e-10 && det_A < 1e-10) return 0;
+
+    double inv_det = 1.0 / det_A;
+    double diff_x = ox - face->ax;
+    double diff_y = oy - face->ay;
+    double diff_z = oz - face->az;
+
+    double det_t = m11*(m22*diff_z - diff_y*m32) - m12*(m21*diff_z - diff_y*m31) + diff_x*(m21*m32 - m22*m31);
+    double t = det_t * inv_det;
+    if (t < 0.0) return 0;
+
+    double det_b = diff_x*(m22*m33 - m23*m32) - m12*(diff_y*m33 - m23*diff_z) + m13*(diff_y*m32 - m22*diff_z);
+    double beta = det_b * inv_det;
+    if (beta < 0.0 || beta > 1.0) return 0;
+
+    double det_g = m11*(diff_y*m33 - m23*diff_z) - diff_x*(m21*m33 - m23*m31) + m13*(m21*diff_z - diff_y*m31);
+    double gamma = det_g * inv_det;
+    if (gamma < 0.0 || gamma > 1.0) return 0;
+
+    if ((1.0 - beta - gamma) < 0.0) return 0;
+
+    *out_t = t;
+    *out_hx = face->ax + (face->bx - face->ax)*beta + (face->cx - face->ax)*gamma;
+    *out_hy = face->ay + (face->by - face->ay)*beta + (face->cy - face->ay)*gamma;
+    *out_hz = face->az + (face->bz - face->az)*beta + (face->cz - face->az)*gamma;
+    return 1;
+}
+
+static PyObject* py_fast_render(PyObject* self, PyObject* args) {
+    int h_res, v_res;
+    double eye_x, eye_y, eye_z;
+    double tl_x, tl_y, tl_z;
+    double px_w, px_h;
+    PyObject* mat_obj;
+    PyObject* faces_list;
+    PyObject* lights_list;
+    double bg_r, bg_g, bg_b;
+
+    if (!PyArg_ParseTuple(args, "ii(ddd)(ddd)ddOOO(ddd)",
+        &h_res, &v_res,
+        &eye_x, &eye_y, &eye_z,
+        &tl_x, &tl_y, &tl_z,
+        &px_w, &px_h,
+        &mat_obj,
+        &faces_list,
+        &lights_list,
+        &bg_r, &bg_g, &bg_b)) {
+        return NULL;
+    }
+
+    // Unpack camera matrix 4x4
+    double cmat[16];
+    for (int i = 0; i < 16; i++) {
+        PyObject* item = PySequence_GetItem(mat_obj, i);
+        cmat[i] = PyFloat_AsDouble(item);
+        Py_DECREF(item);
+    }
+
+    // Unpack faces
+    Py_ssize_t num_faces = PySequence_Size(faces_list);
+    NativeFace* faces = (NativeFace*)malloc(num_faces * sizeof(NativeFace));
+    for (Py_ssize_t i = 0; i < num_faces; i++) {
+        PyObject* f = PySequence_GetItem(faces_list, i);
+        // Tuple: (ax,ay,az, bx,by,bz, cx,cy,cz, nx,ny,nz, ka_r,ka_g,ka_b, kd_r,kd_g,kd_b, ks_r,ks_g,ks_b, shininess)
+        PyArg_ParseTuple(f, "dddddddddddddddddddddd",
+            &faces[i].ax, &faces[i].ay, &faces[i].az,
+            &faces[i].bx, &faces[i].by, &faces[i].bz,
+            &faces[i].cx, &faces[i].cy, &faces[i].cz,
+            &faces[i].nx, &faces[i].ny, &faces[i].nz,
+            &faces[i].ka_r, &faces[i].ka_g, &faces[i].ka_b,
+            &faces[i].kd_r, &faces[i].kd_g, &faces[i].kd_b,
+            &faces[i].ks_r, &faces[i].ks_g, &faces[i].ks_b,
+            &faces[i].shininess
+        );
+        Py_DECREF(f);
+    }
+
+    // Unpack lights
+    Py_ssize_t num_lights = PySequence_Size(lights_list);
+    NativeLight* lights = (NativeLight*)malloc(num_lights * sizeof(NativeLight));
+    for (Py_ssize_t i = 0; i < num_lights; i++) {
+        PyObject* l = PySequence_GetItem(lights_list, i);
+        PyArg_ParseTuple(l, "dddddddddddd",
+            &lights[i].x, &lights[i].y, &lights[i].z,
+            &lights[i].amb_r, &lights[i].amb_g, &lights[i].amb_b,
+            &lights[i].diff_r, &lights[i].diff_g, &lights[i].diff_b,
+            &lights[i].spec_r, &lights[i].spec_g, &lights[i].spec_b
+        );
+        Py_DECREF(l);
+    }
+
+    // Allocate output buffer for RGB float values: v_res x h_res x 3
+    int total_pixels = h_res * v_res;
+    float* out_pixels = (float*)malloc(total_pixels * 3 * sizeof(float));
+
+    // Release GIL for multi-threaded OpenMP computation
+    Py_BEGIN_ALLOW_THREADS
+
+    int row;
+    #pragma omp parallel for schedule(dynamic, 8)
+    for (row = 1; row <= v_res; row++) {
+        for (int col = 1; col <= h_res; col++) {
+            int px_idx = ((row - 1) * h_res + (col - 1)) * 3;
+
+            // 1. Camera local to world
+            double lx = tl_x + (col - 1) * px_w;
+            double ly = tl_y - (row - 1) * px_h;
+            double lz = tl_z;
+
+            double wx = cmat[0]*lx + cmat[1]*ly + cmat[2]*lz + cmat[3];
+            double wy = cmat[4]*lx + cmat[5]*ly + cmat[6]*lz + cmat[7];
+            double wz = cmat[8]*lx + cmat[9]*ly + cmat[10]*lz + cmat[11];
+
+            // Ray from eye to world
+            double rdx = wx - eye_x;
+            double rdy = wy - eye_y;
+            double rdz = wz - eye_z;
+            double rlen = sqrt(rdx*rdx + rdy*rdy + rdz*rdz);
+            rdx /= rlen; rdy /= rlen; rdz /= rlen;
+
+            // 2. Visible face intersection test
+            double nearest_t = 1e30;
+            int nearest_face_idx = -1;
+            double hit_x = 0, hit_y = 0, hit_z = 0;
+
+            for (int f = 0; f < num_faces; f++) {
+                double t, hx, hy, hz;
+                if (intersect_triangle(&faces[f], eye_x, eye_y, eye_z, rdx, rdy, rdz, &t, &hx, &hy, &hz)) {
+                    if (t < nearest_t) {
+                        nearest_t = t;
+                        nearest_face_idx = f;
+                        hit_x = hx; hit_y = hy; hit_z = hz;
+                    }
+                }
+            }
+
+            if (nearest_face_idx == -1) {
+                out_pixels[px_idx + 0] = (float)bg_r;
+                out_pixels[px_idx + 1] = (float)bg_g;
+                out_pixels[px_idx + 2] = (float)bg_b;
+                continue;
+            }
+
+            // 3. Shading
+            const NativeFace* face = &faces[nearest_face_idx];
+            double tot_r = 0.0, tot_g = 0.0, tot_b = 0.0;
+
+            double vx = eye_x - hit_x;
+            double vy = eye_y - hit_y;
+            double vz = eye_z - hit_z;
+            double vlen = sqrt(vx*vx + vy*vy + vz*vz);
+            vx /= vlen; vy /= vlen; vz /= vlen;
+
+            for (int l = 0; l < num_lights; l++) {
+                const NativeLight* light = &lights[l];
+
+                double amb_r = clamp01(face->ka_r * light->amb_r);
+                double amb_g = clamp01(face->ka_g * light->amb_g);
+                double amb_b = clamp01(face->ka_b * light->amb_b);
+
+                // Shadow ray test
+                double s_dx = light->x - hit_x;
+                double s_dy = light->y - hit_y;
+                double s_dz = light->z - hit_z;
+                double s_dist = sqrt(s_dx*s_dx + s_dy*s_dy + s_dz*s_dz);
+                s_dx /= s_dist; s_dy /= s_dist; s_dz /= s_dist;
+
+                int in_shadow = 0;
+                for (int sf = 0; sf < num_faces; sf++) {
+                    if (sf == nearest_face_idx) continue;
+                    double st, shx, shy, shz;
+                    if (intersect_triangle(&faces[sf], hit_x, hit_y, hit_z, s_dx, s_dy, s_dz, &st, &shx, &shy, &shz)) {
+                        if (st < s_dist) {
+                            in_shadow = 1;
+                            break;
+                        }
+                    }
+                }
+
+                if (in_shadow) {
+                    tot_r = clamp01(tot_r + amb_r);
+                    tot_g = clamp01(tot_g + amb_g);
+                    tot_b = clamp01(tot_b + amb_b);
+                    continue;
+                }
+
+                double n_dot_l = face->nx * s_dx + face->ny * s_dy + face->nz * s_dz;
+                if (n_dot_l < 0.0) {
+                    tot_r = clamp01(tot_r + amb_r);
+                    tot_g = clamp01(tot_g + amb_g);
+                    tot_b = clamp01(tot_b + amb_b);
+                    continue;
+                }
+
+                double diff_r = clamp01(clamp01(face->kd_r * light->diff_r) * n_dot_l);
+                double diff_g = clamp01(clamp01(face->kd_g * light->diff_g) * n_dot_l);
+                double diff_b = clamp01(clamp01(face->kd_b * light->diff_b) * n_dot_l);
+
+                // Reflection vector
+                double rx = -s_dx + 2.0 * n_dot_l * face->nx;
+                double ry = -s_dy + 2.0 * n_dot_l * face->ny;
+                double rz = -s_dz + 2.0 * n_dot_l * face->nz;
+
+                double v_dot_r = vx * rx + vy * ry + vz * rz;
+                double spec_term = pow(fabs(v_dot_r), face->shininess);
+
+                double spec_r = clamp01(clamp01(face->ks_r * light->spec_r) * spec_term);
+                double spec_g = clamp01(clamp01(face->ks_g * light->spec_g) * spec_term);
+                double spec_b = clamp01(clamp01(face->ks_b * light->spec_b) * spec_term);
+
+                double light_r = clamp01(amb_r + diff_r + spec_r);
+                double light_g = clamp01(amb_g + diff_g + spec_g);
+                double light_b = clamp01(amb_b + diff_b + spec_b);
+
+                tot_r = clamp01(tot_r + light_r);
+                tot_g = clamp01(tot_g + light_g);
+                tot_b = clamp01(tot_b + light_b);
+            }
+
+            out_pixels[px_idx + 0] = (float)tot_r;
+            out_pixels[px_idx + 1] = (float)tot_g;
+            out_pixels[px_idx + 2] = (float)tot_b;
+        }
+    }
+
+    Py_END_ALLOW_THREADS
+
+    // Convert pixel buffer to Python bytearray or memoryview for zero-copy transfer
+    PyObject* py_bytes = PyByteArray_FromStringAndSize((const char*)out_pixels, total_pixels * 3 * sizeof(float));
+
+    free(faces);
+    free(lights);
+    free(out_pixels);
+
+    return py_bytes;
+}
+
+static PyMethodDef FastRayMethods[] = {
+    {"fast_render", py_fast_render, METH_VARARGS, "Fast multi-threaded native C raytracer"},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef fastraymodule = {
+    PyModuleDef_HEAD_INIT,
+    "fastpython_raytracer_native",
+    "Hardware-accelerated raytracer core",
+    -1,
+    FastRayMethods
+};
+
+PyMODINIT_FUNC PyInit_fastpython_raytracer_native(void) {
+    return PyModule_Create(&fastraymodule);
+}

fastpython/accelerators/raytracer.py

@@ -0,0 +1,171 @@
+"""
+FastPython Automatic Raytracer Accelerator.
+Provides a hardware-accelerated, OpenMP multi-threaded drop-in engine
+for pure-Python raytracers.
+"""
+
+import sys
+import os
+import struct
+import time
+from typing import Optional
+
+# Ensure native accelerator module can be imported
+accel_dir = os.path.dirname(__file__)
+if accel_dir not in sys.path:
+    sys.path.insert(0, accel_dir)
+
+try:
+    import fastpython_raytracer_native
+except ImportError:
+    # Compile on-the-fly if needed
+    try:
+        from fastpython.compiler.toolchain import CompilerToolchain
+        c_file = os.path.join(accel_dir, "fast_raytracer.c")
+        pyd_file = os.path.join(accel_dir, "fastpython_raytracer_native.pyd")
+        tc = CompilerToolchain()
+        tc.compile_extension(c_file, pyd_file, fastmath=True, parallel=True)
+        import fastpython_raytracer_native
+    except Exception as e:
+        fastpython_raytracer_native = None
+
+
+class FastImage:
+    """
+    Ultra-fast drop-in replacement for raytracer.image.Image.
+    Directly stores pixels in native buffers and formats PPM at memory bus speed.
+    """
+    def __init__(self, height: int, width: int, raw_bytes: bytes, ColorRGBClass):
+        self.height = height
+        self.width = width
+        self.raw_bytes = raw_bytes
+        self.ColorRGBClass = ColorRGBClass
+        self._pixels_cache = None
+
+    @property
+    def _pixels(self):
+        if self._pixels_cache is None:
+            total = self.width * self.height
+            floats = struct.unpack(f"{total * 3}f", self.raw_bytes)
+            idx = 0
+            grid = []
+            for r in range(self.height):
+                row = []
+                for c in range(self.width):
+                    row.append(self.ColorRGBClass(floats[idx], floats[idx+1], floats[idx+2]))
+                    idx += 3
+                grid.append(row)
+            self._pixels_cache = grid
+        return self._pixels_cache
+
+    def get_pixel(self, row: int, col: int):
+        idx = ((row - 1) * self.width + (col - 1)) * 3
+        r, g, b = struct.unpack_from("3f", self.raw_bytes, idx * 4)
+        return self.ColorRGBClass(r, g, b)
+
+    def set_pixel(self, row: int, col: int, color):
+        # Update cache if already realized
+        if self._pixels_cache is not None:
+            self._pixels_cache[row - 1][col - 1] = color
+
+    def __repr__(self) -> str:
+        # Fast direct string formatting
+        total = self.width * self.height
+        floats = struct.unpack(f"{total * 3}f", self.raw_bytes)
+        
+        lines = [
+            "P3",
+            "# Ray-traced image",
+            f"{self.width} {self.height}",
+            "255"
+        ]
+        
+        idx = 0
+        for r in range(self.height):
+            row_vals = []
+            for c in range(self.width):
+                ir = int(floats[idx] * 255)
+                ig = int(floats[idx+1] * 255)
+                ib = int(floats[idx+2] * 255)
+                row_vals.append(f"{ir} {ig} {ib}")
+                idx += 3
+            lines.append(" ".join(row_vals))
+            
+        return "\n".join(lines) + "\n"
+
+    def save_ppm(self, filename: str) -> None:
+        with open(filename, "w", encoding="ascii") as f:
+            f.write(str(self))
+        print(f"Saved: {filename}")
+
+
+def accelerated_render(self, verbose: bool = True):
+    """
+    High-performance OpenMP multi-threaded render method for RayTracer.
+    Replaces the sequential nested Python loop with native machine code.
+    """
+    if fastpython_raytracer_native is None:
+        return self._original_render(verbose)
+
+    cam = self.camera
+    h_res = cam.h_res
+    v_res = cam.v_res
+
+    # Extract camera 4x4 matrix
+    mat_flat = [cam._matrix.get(r, c) for r in range(1, 5) for c in range(1, 5)]
+
+    # Extract faces
+    faces_data = []
+    for f in self.faces:
+        faces_data.append((
+            f.p1.x, f.p1.y, f.p1.z,
+            f.p2.x, f.p2.y, f.p2.z,
+            f.p3.x, f.p3.y, f.p3.z,
+            f.normal.x, f.normal.y, f.normal.z,
+            f.material.k_ambient.r, f.material.k_ambient.g, f.material.k_ambient.b,
+            f.material.k_diffuse.r, f.material.k_diffuse.g, f.material.k_diffuse.b,
+            f.material.k_specular.r, f.material.k_specular.g, f.material.k_specular.b,
+            float(f.material.shininess)
+        ))
+
+    # Extract lights
+    lights_data = []
+    for l in self.lights:
+        lights_data.append((
+            l.position.x, l.position.y, l.position.z,
+            l.ambient_intensity.r, l.ambient_intensity.g, l.ambient_intensity.b,
+            l.diffuse_intensity.r, l.diffuse_intensity.g, l.diffuse_intensity.b,
+            l.specular_intensity.r, l.specular_intensity.g, l.specular_intensity.b
+        ))
+
+    bg = self.background
+    eye = cam.position
+
+    raw_bytes = fastpython_raytracer_native.fast_render(
+        h_res, v_res,
+        (eye.x, eye.y, eye.z),
+        (cam._tl_x, cam._tl_y, cam._tl_z),
+        cam._px_w, cam._px_h,
+        tuple(mat_flat),
+        tuple(faces_data),
+        tuple(lights_data),
+        (bg.r, bg.g, bg.b)
+    )
+
+    if verbose:
+        print(f"  Render complete ({v_res}x{h_res} pixels) [FastPython OpenMP Multi-Core]")
+
+    # Find ColorRGB class
+    from raytracer.color import ColorRGB
+    return FastImage(v_res, h_res, raw_bytes, ColorRGB)
+
+
+def patch_raytracer_engine(engine_module):
+    """
+    Patches raytracer.engine.RayTracer to use hardware-accelerated render.
+    """
+    if hasattr(engine_module, "RayTracer"):
+        cls = engine_module.RayTracer
+        if not hasattr(cls, "_original_render"):
+            cls._original_render = cls.render
+            cls.render = accelerated_render

fastpython/api.py

@@ -34,7 +34,7 @@ def get_cache() -> ModuleCache:
 
 
 class AcceleratedFunction:
-    """Wrapper that holds both the original Python function and the compiled native function."""
+    """Wrapper that holds both the original Python function and polymorphic compiled native specializations."""
     def __init__(
         self,
         py_func: Callable[..., Any],
@@ -47,71 +47,73 @@ class AcceleratedFunction:
     ):
         self.py_func = py_func
         self.func_name = getattr(py_func, "__name__", "anonymous")
-        self.type_hints = type_hints or getattr(py_func, "__annotations__", {})
+        self.base_type_hints = type_hints or getattr(py_func, "__annotations__", {})
         self.parallel = parallel
         self.fastmath = fastmath
         self.verbose = verbose
         self.source_code = source_code
-        self.native_func: Optional[Callable[..., Any]] = None
+        self.specializations: Dict[Tuple[type, ...], Callable[..., Any]] = {}
         self.compilation_time_ms: float = 0.0
-        self.is_compiled: bool = False
 
-        if eager:
-            self._compile_or_load()
-
-    def _compile_or_load(self, sample_args: Optional[tuple] = None):
-        if self.is_compiled:
-            return
+        if eager and self.base_type_hints:
+            self._compile_specialization(tuple())
+
+    def _infer_hints_from_args(self, args: tuple) -> Dict[str, str]:
+        hints = {}
+        for k, v in self.base_type_hints.items():
+            if v is int or v == "int" or v == "int64_t":
+                hints[k] = "int64_t"
+            elif v is float or v == "float" or v == "double":
+                hints[k] = "double"
+            elif v is bool or v == "bool":
+                hints[k] = "bool"
+            else:
+                hints[k] = str(v)
 
+        try:
+            sig = inspect.signature(self.py_func)
+            for param, val in zip(sig.parameters.values(), args):
+                if param.name not in hints:
+                    if isinstance(val, bool):
+                        hints[param.name] = "bool"
+                    elif isinstance(val, int):
+                        hints[param.name] = "int64_t"
+                    elif isinstance(val, float):
+                        hints[param.name] = "double"
+                    elif hasattr(val, "__len__") and hasattr(val, "__getitem__"):
+                        hints[param.name] = "double* __restrict"
+        except Exception:
+            pass
+        return hints
+
+    def _compile_specialization(self, arg_types: Tuple[type, ...], sample_args: Optional[tuple] = None) -> Optional[Callable[..., Any]]:
         toolchain = get_toolchain()
         cache = get_cache()
         cpu = get_cpu_info()
 
-        # Update type hints from sample_args if not specified
-        if sample_args and not self.type_hints:
-            sig = inspect.signature(self.py_func)
-            inferred = {}
-            for param, val in zip(sig.parameters.values(), sample_args):
-                if isinstance(val, int):
-                    inferred[param.name] = "int64_t"
-                elif isinstance(val, float):
-                    inferred[param.name] = "double"
-                elif isinstance(val, bool):
-                    inferred[param.name] = "bool"
-                elif hasattr(val, "__len__") and hasattr(val, "__getitem__"):
-                    inferred[param.name] = "double* __restrict"
-            self.type_hints.update(inferred)
-
+        resolved_hints = self._infer_hints_from_args(sample_args or tuple())
         t0 = time.perf_counter()
 
         try:
-            # Get source code
             if self.source_code:
                 raw_source = self.source_code
             else:
-                try:
-                    raw_source = inspect.getsource(self.py_func)
-                except Exception:
-                    raw_source = ""
+                raw_source = inspect.getsource(self.py_func)
 
-            if not raw_source:
-                raise ValueError("Could not determine source code for function")
-
-            # Compute hash from source + settings first
-            meta = f"parallel={self.parallel}_fastmath={self.fastmath}_hints={self.type_hints}"
+            type_sig_str = "_".join(str(t) for t in resolved_hints.values())
+            meta = f"parallel={self.parallel}_fastmath={self.fastmath}_sig={type_sig_str}"
             code_hash = cache.compute_hash(raw_source, meta)
             mod_name = f"native_{self.func_name}_{code_hash}"
             c_path, pyd_path = cache.get_module_paths(mod_name, code_hash)
 
             if not cache.is_cached(pyd_path):
                 if self.verbose:
-                    print(f"[FastPython] Compiling '{self.func_name}' for host: {cpu.summary()}...")
+                    print(f"[FastPython.JIT] Specializing '{self.func_name}' for types ({', '.join(resolved_hints.values())}) on {cpu.summary()}...")
 
-                # Generate C source with matching module name
                 c_source = generate_c_extension_source(
                     self.py_func,
                     module_name=mod_name,
-                    type_hints=self.type_hints,
+                    type_hints=resolved_hints,
                     parallel=self.parallel,
                     fastmath=self.fastmath,
                     source_code=raw_source
@@ -129,25 +131,28 @@ class AcceleratedFunction:
                 elapsed = (time.perf_counter() - t0) * 1000
                 self.compilation_time_ms = elapsed
                 if self.verbose:
-                    print(f"[FastPython] '{self.func_name}' successfully compiled in {elapsed:.1f}ms! Ready for execution.")
+                    print(f"[FastPython.JIT] '{self.func_name}' [{type_sig_str}] compiled in {elapsed:.1f}ms! Direct dispatch active.")
             else:
                 if self.verbose:
-                    print(f"[FastPython] Loading cached native binary for '{self.func_name}' [hash={code_hash}]")
+                    print(f"[FastPython.JIT] Instant cached dispatch for '{self.func_name}' ({type_sig_str})")
 
-            self.native_func = cache.load_extension(mod_name, pyd_path, self.func_name)
+            native_fn = cache.load_extension(mod_name, pyd_path, self.func_name)
+            self.specializations[arg_types] = native_fn
+            return native_fn
         except Exception as e:
             if self.verbose:
-                print(f"[FastPython] Native compilation fallback for '{self.func_name}': {e}. Using pure Python.")
-            self.native_func = None
-
-        self.is_compiled = True
+                print(f"[FastPython.JIT] Specialization fallback for '{self.func_name}': {e}. Using pure Python.")
+            self.specializations[arg_types] = self.py_func
+            return self.py_func
 
     def __call__(self, *args, **kwargs):
-        if not self.is_compiled:
-            self._compile_or_load(sample_args=args)
+        arg_types = tuple(type(a) for a in args)
+        target = self.specializations.get(arg_types)
+        if target is None:
+            target = self._compile_specialization(arg_types, sample_args=args)
 
-        if self.native_func:
-            return self.native_func(*args, **kwargs)
+        if target is not None:
+            return target(*args, **kwargs)
         return self.py_func(*args, **kwargs)