SMILE (Statistical Machine Intelligence & Learning Engine) is a comprehensive, high-performance machine learning and AI platform for the JVM. Built on Java 25 with idiomatic APIs for Kotlin and Scala (v4.x supports Java 21; earlier versions support Java 8), SMILE covers the entire lifecycle of machine intelligence: building models with agentic AutoML, embedding algorithms directly in your application, and serving classical ML, ONNX graphs, and LLMs on your own machines.

A decision should not require a cloud round-trip or a fragile bridge to an external Python stack. The score, the explanation, and the model update belong on the machine that already holds the facts: inside a JVM microservice, a branch server, a payment terminal, a vehicle gateway, or an air-gapped node. SMILE makes real-time, autonomous machine intelligence native to the systems enterprises already run, from resource-constrained edge gateways to multi-GPU clusters.

• Sovereign & Self-Hosted by Default: Your data, models, API keys, and telemetry stay on your machines and your network. Everything is built to run locally and keep working when the external link is down.
• Zero-Bloat Craftsmanship: The core engine is pure, self-contained JVM bytecode built on compact, cache-friendly data structures. You get deterministic low latency and a tiny memory footprint by default, with optional plug-and-play native acceleration (OpenBLAS/LAPACK, ONNX Runtime, LibTorch/CUDA) when hardware is available.
• Explainable & Auditable in Place: High-stakes decisions cannot be black boxes. SMILE provides both exact TreeSHAP for tree ensembles and model-agnostic KernelSHAP for any classifier or regressor, computing local feature attributions in-process alongside predictions, while AutoML workflows generate readable Java, Scala, Kotlin, or Python notebooks you can inspect line by line.
• Open Source with Enterprise Backing: Open-source licensing supports academic research and community collaboration, while commercial licensing from HALO.AI removes copyleft and source-disclosure obligations for proprietary, embedded, and mission-critical production deployments.

• Comprehensive Breadth in One Engine: Hundreds of algorithms spanning classification, regression, clustering, manifold learning, time series, anomaly detection, NLP, statistical testing, linear algebra, deep learning, computer vision, and native LLM inference (MiniMax M3, Qwen, Llama, tiktoken, Radix KV cache, MTP speculative decoding).
• State-of-the-Art Speed & Footprint: Engineered with primitive-backed memory layouts, Panama FFM, and the Java Vector API (SIMD), SMILE routinely outperforms R, Python, Spark, and H2O while scaling down to a 0.2 GB GraalVM native micro-container that boots in 0.4 s and idles at ~80 MiB RAM.
• On-Device Training & Adaptation: Unlike static inference-only runtimes, SMILE trains and updates models (Random Forests, Gradient Boosting, K-Means, DBSCAN, anomaly detectors) directly on live edge or application data.
• Built for Agentic & Production Workloads: Continuous batching, prefix-preserving Radix KV caches, and speculative decoding that retains its speedup under full batch load, paired with atomic model hot-swapping, Kubernetes health probes, and Prometheus metrics.

Call classification, regression, clustering, deep learning, NLP, and visualization directly in-process from Java, Scala, or Kotlin with no separate service to operate.

A production-ready, Quarkus-based inference server (available as JVM, CUDA GPU, and GraalVM native containers) that brings together three complementary inference capabilities in a single process:

A React-based web UI is bundled and served from the same process. See serve/README.md for how to build and run the service.

A desktop workplace for data science and software engineering using Python, Java, Kotlin, or Scala. Specialized AI agents collaborate with you in interactive notebooks to explore data, engineer features, train and tune models, and export .sml or .onnx artifacts directly to SMILE Serve. See studio/README.md to get your first project running in a few minutes.

1. Features
2. Module Map
3. Installation
   • Maven
   • SBT (Scala)
   • Gradle (Kotlin)
   • Native Libraries (BLAS / LAPACK)
4. Quick Start
5. SMILE Studio & Shell
6. Model Serialization
7. Visualization
8. License
9. Issues & Discussions
10. Contributing
11. Maintainers
12. Gallery

Each module has its own detailed user guide. Click the README link for the module overview, or drill into individual topic guides.

Data structures, math, linear algebra, statistical utilities, I/O

Classification, regression, clustering, manifold learning, and more

LibTorch-backed GPU/CPU tensor operations, neural network layers, LLaMA-3 inference, EfficientNet, ONNX Runtime & GenAI

The deep/README.md covers:

• smile.deep.tensor — Tensor factory, indexing, arithmetic, AutoScope memory management, dtype/device
• smile.deep.layer — Linear, Conv2d, pooling, normalization (BN/GN/RMS), dropout, embedding, sequential blocks
• smile.deep.activation — ReLU, GELU, SiLU, Tanh, Sigmoid, Softmax, GLU, HardShrink, …
• smile.deep.Loss — MSE, cross-entropy, BCE, Huber, KL, hinge, and more
• smile.deep.Optimizer — SGD, Adam, AdamW, RMSprop
• smile.deep.Model — Abstract base class + training loop
• smile.deep.metric — Accuracy, Precision, Recall, F1Score with macro/micro/weighted averaging
• smile.deep.Dataset — Dataset interface, DataSampler, SampleBatch

The deep/LLM.md covers:

• smile.llm — Message, Role, FinishReason, ChatCompletion, ChatOptions, LanguageModel
• smile.llm.tokenizer — Tokenizer interface, Tiktoken BPE implementation (LLaMA-3 compatible)
• smile.llm.model.llama — Full LLaMA-3 stack: Llama.build(), generate(), chat(), streaming
• smile.llm.model.qwen — Qwen3.5 hybrid stack (Gated DeltaNet + gated attention), MTP, vision tower
• smile.llm.engine — Continuous-batching InferenceEngine, GenerationRequest/GenerationHandle, speculative decoding
• smile.llm.cache — Paged KvCachePool, RadixCache prefix reuse
• smile.llm.quant / smile.llm.parallel — FP8/NVFP4/Marlin quantization, tensor parallelism

The deep/VISION.md covers:

• smile.vision — VisionModel, ImageDataset, EfficientNet.V2S/M/L() pretrained models, ImageNet labels
• smile.vision.transform — Transform interface, ImageClassification pipeline, resize/crop/toTensor helpers

Text normalization, tokenization, POS tagging, stemming, relevance ranking

Swing-based interactive plots and declarative Vega-Lite charts

Quarkus-based REST inference service with OpenAI-compatible API and SSE streaming

An agentic IDE for data science using Python or SMILE

Idiomatic Scala shim — concise wrappers, symbolic operators, Scala collections integration

Idiomatic Kotlin shim — extension functions, named parameters, builder DSLs

Lightweight zero-dependency JSON library for Scala with a clean DSL

Use SMILE models inside Spark ML pipelines

<!-- Core ML algorithms -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-core</artifactId>
  <version>7.1.0</version>
</dependency>

<!-- Deep learning + LLMs (requires LibTorch) -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-deep</artifactId>
  <version>7.1.0</version>
</dependency>

<!-- Natural language processing -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-nlp</artifactId>
  <version>7.1.0</version>
</dependency>

<!-- Data visualization -->
<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-plot</artifactId>
  <version>7.1.0</version>
</dependency>

libraryDependencies += "com.github.haifengl" %% "smile-scala" % "7.1.0"

dependencies {
    implementation("com.github.haifengl:smile-kotlin:7.1.0")
}

Several algorithms (manifold learning, Gaussian Process, MLP, some clustering) require BLAS and LAPACK.

Linux (Ubuntu / Debian)

sudo apt update
sudo apt install libopenblas-dev libarpack2-dev

macOS (Homebrew)

brew install arpack

Do not rely on DYLD_LIBRARY_PATH: macOS System Integrity Protection (SIP) strips DYLD_* variables when the JVM is started through the /usr/bin/java stub, so dyld never sees them. SMILE reaches libarpack through the FFM bindings, whose SymbolLookup.libraryLookup("arpack") calls dlopen on the bare name libarpack.dylib; this does not consult java.library.path, so -Djava.library.path=... and LD_LIBRARY_PATH have no effect either. SMILE therefore preloads the library by absolute path through smile.linalg.NativeLibrary, which finds it under /opt/homebrew/lib or /usr/local/lib with no copy or symlink. To point it somewhere else, set the arpack.native.path system property or the ARPACK_NATIVE_PATH environment variable.

Windows — pre-built DLLs are included in the bin/ directory of the release package. Add that directory to PATH.

GPU (CUDA) — make sure the LibTorch CUDA native libraries are on PATH (Windows) or LD_LIBRARY_PATH (Linux).

import smile.classification.RandomForest;
import smile.data.formula.Formula;
import smile.io.Read;

// Load data
var data = Read.csv("src/test/resources/iris.csv");

// Train a random forest
var forest = RandomForest.fit(Formula.lhs("species"), data);

// Predict
int label = forest.predict(data.get(0));
System.out.println("Predicted class: " + label);

For deep learning examples, see deep/README.md; for LLM and computer-vision examples, see deep/LLM.md and deep/VISION.md. For visualization examples, see plot/README.md.

SMILE Studio is an agentic IDE for data science using Python or SMILE on JVM. See studio/README.md for full documentation.

Download a pre-packaged release from the releases page, then:

path/to/smile/bin/setup      # install required native dependencies
path/to/smile/bin/smile      # launch SMILE Studio from your project directory

Other entry points:

To increase the JVM heap:

path/to/smile/bin/smile -J-Xmx30G

Most SMILE models implement java.io.Serializable. You can serialize a trained model to disk and load it in a production environment or inside a Spark job:

// Save
try (var out = new ObjectOutputStream(new FileOutputStream("model.ser"))) {
    out.writeObject(forest);
}

// Load
try (var in = new ObjectInputStream(new FileInputStream("model.ser"))) {
    var loaded = (RandomForest) in.readObject();
}

SMILE provides two visualization layers:

• smile.plot.swing — Swing-based interactive 2D/3D plots. See plot/README.md.
• smile.plot.vega — Declarative Vega-Lite charts for browsers and Jupyter. See plot/VEGA.md.

<dependency>
  <groupId>com.github.haifengl</groupId>
  <artifactId>smile-plot</artifactId>
  <version>7.1.0</version>
</dependency>

SMILE uses a multi-license model that keeps academic research and open-source collaboration free while providing standard, upfront commercial licenses—administered by HALO.AI LLC—for proprietary distribution and production deployments:

All commercial tiers include Critical & High CVE resolution SLAs and a 12-month capped IP indemnity. See LICENSE and Commercial Licensing & Pricing, or contact sales@aihalo.dev.

Please read CONTRIBUTING.md for build and test instructions.

• Haifeng Li (@haifengl)
• Karl Li (@kklioss)

Scatterplot Matrix
Scatter Plot	Line Plot	Surface Plot
Bar Plot	Box Plot	Histogram Heatmap
Rolling Average	Geo Map	UMAP
Text Plot	Heatmap with Contour	Hexmap
IsoMap	LLE	Kernel PCA
Neural Network	SVM	Hierarchical Clustering
SOM	DBSCAN	Neural Gas
Wavelet	Exponential Family Mixture	Teapot Wireframe
Grid Interpolation