cloudparts

Nuclio

Open-source functions for Kubernetes or plain Docker, built for event streams and data work: each function is a long-running processor that reads from HTTP, Kafka, Kinesis, MQTT and other sources with several parallel workers.

What it is
Serverless functions (FaaS)
Type
Open source
Made by
Iguazio (part of McKinsey’s QuantumBlack since 2023)
License
Apache 2.0
Facts checked
23 October 2026
Website Source code

What it is

In Nuclio you give a handler and a configuration that names its triggers. A builder packs the handler into a container image together with Nuclio’s processor, the program that actually runs it, and pushes the image to a registry. On Kubernetes the deployer then writes a NuclioFunction custom resource, and Nuclio’s controller turns that into a Deployment, Service, Ingress and autoscaler. The same functions can also run as containers on a single Docker host, which is how the quick start runs it.

The processor is the entry point of every function container. It connects to the function’s event sources itself: it listens for HTTP, consumes from Kafka, Kinesis, RabbitMQ, NATS, MQTT, Azure Event Hubs or Iguazio’s V3IO streams, or fires on a cron schedule, so there is no central router in the request path. Each trigger hands events to a configurable number of workers that call your handler in parallel, with Go handlers running inside the processor and Python, Node.js and Java handlers in a separate process that talks to it. Handlers can be written in Go, Python, Node.js, Java, .NET Core or as shell commands. Functions scale between minReplicas and maxReplicas on CPU, and a separate scaler service can take them down to zero and wake them on the next request.

Iguazio built Nuclio for its own data platform and released it as open source in December 2017. It is also the serving and real-time layer of MLRun, Iguazio’s open-source MLOps framework. McKinsey bought Iguazio in January 2023 and folded it into QuantumBlack, its AI arm. Nuclio is still actively maintained in October 2026: it had 41 releases on GitHub that year across two supported lines, the latest being 1.17.10 and 1.16.12 in mid-October.

Why teams pick it

  • Built for throughput: each function is a long-lived process with several workers per trigger, so it suits steady streams of events or records rather than only occasional HTTP calls
  • Many event sources built into the processor, including Kafka, Kinesis, RabbitMQ, NATS, MQTT and cron, with no separate router or trigger service in the path
  • Runs on Kubernetes or on a single Docker host, which helps for local development and edge machines
  • GPU requests and integration with Jupyter, MLRun and Kubeflow Pipelines make it a common way to serve models and real-time feature steps

Watch out for

  • Every deploy builds and pushes a container image, so you need a container registry and deploys are slower than loading code into a warm pod
  • Autoscaling between replicas follows CPU usage, and scaling to and from zero needs the extra scaler service
  • Development is led almost entirely by Iguazio, now part of McKinsey, and some features target Iguazio’s commercial platform, such as V3IO streams
  • More moving parts than a hosted FaaS: you run the dashboard, controller, registry and scaler as well as the functions

Alternatives

What all serverless functions (faas) have in common →Compare side by side →
FissionOpen sourceOpen-source functions on Kubernetes: a pool of warm, generic pods takes your code on the first call, so cold starts stay around 100 ms.KubelessArchivedOpen sourceAn archived Kubernetes-native functions framework: each function was a custom resource that a controller turned into its own Deployment and Service, triggered over HTTP, by cron or from Kafka, NATS or Kinesis.

How it fits with other technologies

function.yaml: a Python handler on HTTP with four workers, plus a timer, scaling on CPU · yaml

apiVersion: "nuclio.io/v1"
kind: NuclioFunction
metadata:
  name: my-function
  namespace: nuclio
spec:
  runtime: python
  handler: my_function:my_entry_point   # def my_entry_point(context, event)
  minReplicas: 1
  maxReplicas: 8
  targetCPU: 60
  triggers:
    http:
      kind: http
      numWorkers: 4
      attributes:
        serviceType: NodePort
    periodic:
      kind: cron
      attributes:
        interval: 3s

See it in a real stack

No architecture uses Nuclio yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2014–2026

Iguazio, an Israeli company founded in 2014 by Asaf Somekh, Yaron Haviv, Orit Nissan-Messing and Yaron Segev, sold a data platform for real-time analytics. Its engineers began Nuclio in 2017 for the platform’s own event-heavy workloads; as Haviv put it, none of the existing serverless platforms had been built by infrastructure people. Iguazio released it as open source on December 6, 2017, claiming it could process up to 400,000 events per second against 2,000 on AWS Lambda.

Version 1.0 followed in February 2019. Nuclio then became part of Iguazio’s machine-learning stack: functions can be created from Jupyter notebooks, it serves models and real-time steps in the open-source MLRun framework, and it is used inside Kubeflow Pipelines.

McKinsey announced the purchase of Iguazio in January 2023, its first acquisition in Israel, and merged the team into QuantumBlack, AI by McKinsey. Unlike several Kubernetes function frameworks from the same years, such as VMware’s Kubeless, Nuclio has kept a steady release pace since: two maintained version lines and more than forty releases in 2026.

Why it’s built this way

The function process reads its own event sources
Connecting to Kafka or listening for HTTP inside the processor, instead of pushing every event through a router, removes a hop and lets one function keep up with a high-volume stream.
Parallel workers inside one function instance
A single container processes several events at a time, so a busy function needs fewer replicas than a model with one event per instance.
Build an image per function
Each function is a self-contained container that runs the same way on Kubernetes, on a Docker host or at the edge, at the cost of a build and a registry push on every deploy.
Scale to zero as a separate service
Running functions scale themselves without the dashboard or controller; only waking a function from zero needs the scaler, so the rest of the control plane can be down without stopping traffic.

Timeline

  1. 2014

    Iguazio founded in Israel

  2. 2017

    Nuclio released as open source on December 6

  3. 2019

    Version 1.0.0 released in February

  4. 2023

    McKinsey acquires Iguazio and folds it into QuantumBlack

  5. 2026

    Two maintained lines, 1.16 and 1.17; 1.17.10 released in October

Sources8 · facts checked 23 October 2026

Improve this page on GitHub