Open-source · Local AI inference

Local AI inference. Built for control.

An inference engine for developers who want to understand, optimize, and control how language models run.

Runs
Local-first, offlineStable
CPU
AVX2 · AVX-512 · NEONStable
GPU
Metal · Vulkan · CUDAPreview
API
OpenAI-compatibleStable

The background illustration is decorative and does not show live engine activity.

01 — Premise

An inference engine is more than a model loader.

Between a prompt and a token sits a chain of decisions: which device executes each operation, how tensors are laid out in memory, when a waiting request joins a running batch, and which cached state can be reused.

DynaLM keeps those decisions visible. It is built in layers you can read, measure and change — from the serving scheduler down to the kernels.

02 — Architecture

Four layers, one execution path.

Each layer has a single responsibility and a stated maturity. Select a layer to see what it owns.

  • StableReady for everyday use.
  • PreviewWorks and passes the test suite. Feedback welcome.
  • ExperimentalResearch code. Interfaces and results may change.

Maturity reflects the repository on the snapshot date. DynaKernel is experimental research code.

Full architecture

  1. DynaLM, Runtime · serving · scheduling

    Stable

    The engine people run. Loads models, schedules requests, batches decode steps and serves the OpenAI-compatible HTTP API and CLI.

    • CLI: pull · run · serve
    • Continuous batching
    • Paged KV cache
    • HTTP API & metrics
    Read about DynaLM
  2. DynaCore, Devices · tensors · memory · CPU kernels

    Stable

    The device abstraction beneath the runtime. Owns tensor storage, memory mapping and the SIMD CPU kernels, and exposes GPU devices through one interface. CPU stable · GPU backends in preview.

    • Device abstraction
    • Tensor & memory layout
    • AVX2 · AVX-512 · NEON kernels
    • Metal · Vulkan · CUDA devices
    Read about DynaCore
  3. DynaIR, Inference graph · execution planning

    Preview

    An intermediate representation of the model forward pass. Used to plan execution, fuse operations and drive the compiled kernel mode.

    • Graph representation
    • Execution planning
    • Operation fusion
    • Compiled mode
    Read about DynaIR
  4. DynaKernel, Low-level kernel generation

    Experimental

    Experimental kernel code generation, including an LLVM-based JIT path. Not required to run models and not part of any stability promise.

    • Kernel codegen
    • LLVM JIT backend
    • Compact weight layouts
    • Kernel benchmarks
    Read about DynaKernel

03 — Capabilities

Control at every stage of a request.

3.1

Execution control

Choose the device per run or let the engine pick: GPU first, CPU when the GPU cannot run the model. Execution modes trade speed against a stated accuracy contract.

  • --backend auto
  • --cpu
  • --gpu
  • --mode auto | exact | safe

Execution flow

request --backend auto
GPUif the model is supported · preview CPUotherwise · stable
Illustrative

3.2

Scheduling and batching

Requests join a running batch between decode steps instead of waiting for it to drain. Chunked prefill keeps long prompts from stalling active streams.

  • Continuous batching
  • Chunked prefill

Scheduler

prefill decode step · Illustrative

3.3

Memory and KV cache

Attention state lives in fixed-size pages from a shared, reference-counted pool. Requests with a common prefix share the same pages.

  • Paged KV cache
  • Prefix sharing
  • Q8_0 KV pages

KV cache

shared private page · Illustrative

3.4

Developer-oriented serving

One native binary with an OpenAI-compatible API, so existing SDKs and tools connect by changing the base URL.

API documentation

  • POST/v1/chat/completions
  • POST/v1/completions
  • GET/v1/models
  • GET/health
  • GET/metrics
Base URL http://127.0.0.1:8000/v1

04 — Quick start

From install to an API in three commands.

Commands as documented in the project README. Check the installation guide for Windows, Docker and source builds.

Installation guide

Quick start

Install & run

# Install (Linux and macOS)
curl -fsSL https://raw.githubusercontent.com/dynalm-project/dynalm/main/scripts/install.sh | sh

# Download a model and chat with it
dynalm pull qwen2.5:1.5b
dynalm run qwen2.5:1.5b

Serve

# Start a local OpenAI-compatible server
dynalm serve qwen2.5:1.5b          # http://127.0.0.1:8000/v1

# Check what your machine supports
dynalm doctor

Python client

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="local")
reply = client.chat.completions.create(
    model="qwen2.5:1.5b",
    messages=[{"role": "user", "content": "Give me three tips for clean code."}],
)
print(reply.choices[0].message.content)

Source: README · Quick start (opens in a new tab)

05 — Benchmarks

Measured, or not shown.

Performance numbers will appear here only with the hardware, model, quantization, backend and method that produced them.

Reproducible performance results are being prepared.

Every number on this page will come with its hardware, model, quantization, backend, method and reproduction commands. Until then, nothing is shown.

Decode throughput

—tok/s: not yet measured

Output tokens generated per second for one stream, after the first token.

↑ higher is betterAwaiting run

Prefill throughput

—tok/s: not yet measured

Prompt tokens processed per second before generation starts.

↑ higher is betterAwaiting run

Time to first token

—ms: not yet measured

Median delay from request arrival to the first streamed token.

↓ lower is betterAwaiting run

Multi-user throughput

—tok/s: not yet measured

Total output tokens per second across all concurrent requests.

↑ higher is betterAwaiting run

Inter-token latency P95 / P99

—ms: not yet measured

99th-percentile gap between consecutive tokens — the stutter users notice.

↓ lower is betterAwaiting run

Memory usage

—MB: not yet measured

Peak resident memory of the server process, model loaded.

↓ lower is betterAwaiting run

Every result will state

Hardware
Not yet published
Operating system
Not yet published
Model
Not yet published
Quantization
Not yet published
Backend
Not yet published
DynaLM version
Not yet published
Comparison baseline
Not yet published
Load generator
Not yet published

07 — Roadmap

What works, what is next.

Status copied from the repository. No dates, no percentages — only what is known.

Available15

  • Model compatibilityLlama, Qwen, Gemma, Phi, Mistral, Granite families
  • Model compatibilityGGUF, SafeTensors, GPTQ and AWQ loading
  • CPU inferenceAVX2 and NEON SIMD kernels
  • CPU inferenceWindows on ARMPreview

In progress4

  • CPU inferenceIntel AMX / AVX-512 matrix acceleration
  • GPU executionGPU multi-user throughput
  • Performance and benchmarkingPublic, reproducible benchmark dashboard on this site
  • DocumentationDocumentation hosted on dynalm.in

Planned6

  • Model compatibilityRemaining i-quant types (IQ1–IQ3), TQ1_0/TQ2_0, MXFP4
  • Model compatibilityVision-language models
  • Scheduling and batchingDisaggregated prefill and decode serving
  • Memory optimizationFP8 / FP4 microscaling formats

Build closer to the inference layer.

Explore the engine. Follow the work. Help shape what comes next.