Investigate model behavior. Test hypotheses. See what changes.
Download for Mac · Run your first experiment · Website · App handbook · Python SDK · HTTP API · MCP
Dyno Lab is a free, open-source Mac app for running AI models and investigating how they behave. Ask a question, inspect a request, capture internal activations, and test a hypothesis in the same visual workspace. Save the results, compare experiments, or automate them with the SDK and API.
Start with a model on your Mac. For larger GGUF models, an experimental local GPU pool can connect your Mac and a Windows NVIDIA worker. You do not need a pool to start learning.
Watch the 45-second app tour · Run your first experiment
The edited tour combines real model-selection, request, activation and pool captures with a saved probe recording. These are separate runs, not continuous execution. Full probe protocol and controls.
Start a model or pool, then open Lab → Studies. Keep your question, prompts, results and observations in one local notebook. Watch thinking and answers stream, compare revisions, and archive clutter without losing the evidence. Token limits and incomplete runs are visible rather than silently treated as answers.
Studies guide · Sycophancy reproduction
- Download the Apple Silicon DMG, open it and drag Dyno into Applications.
- Open Dyno. In Discover, download an MLX model that fits your Mac, then select and start it in Models.
- Try a prompt in Chat, see the request in Execution, then capture your first activation map.
Requires Apple Silicon and macOS 14+. Python and MLX are bundled; model weights are downloaded separately. The product is Dyno Lab; the installed bundle is Dyno.app, the command is dyno, and the Python distribution is mlx-dyno.
In-app updates: use Updates in the toolbar to check for new releases or enable automatic checks. Installation asks before restarting. Existing 0.4.2 installations need one manual upgrade to 0.4.3 to receive the updater. See app updates.
Download 0.4.3. Adds signed in-app updates, visible app versions and reviewed study sharing/import. Upgrade manually once from 0.4.2; future updates are available inside Dyno. Release notes.
| Setup | Model format | What it supports |
|---|---|---|
| One Apple Silicon Mac | MLX | Local chat and inference, resident activation capture, and isolated Lab experiments. This is the simplest starting point. |
| Mac + paired Windows NVIDIA worker | GGUF, supported layouts | Experimental pooled inference and resident Lab capture/interventions; probe and SAE fitting runs on the coordinator. |
| Other computers on your LAN | A model served by Dyno | Opt-in shared inference through the router. This does not make research endpoints remotely accessible. |
MLX and GGUF weights are not interchangeable. An isolated MLX experiment loads another model copy; resident capture and pool research reuse loaded weights but still need workspace. Check the app's readiness estimate before running. Pool compatibility and setup.
Why does a model change a harmless reference, sometimes with a safety explanation? Run the Qwen3.8 identifier-fidelity experiment: 72 actual responses, held-out identifiers, a saved layer-32 probe and input-only controls. Watch the native Lab walkthrough.
The small held-out test caught 7 missing-reference outcomes with 2 false alarms. A token-count baseline also performed well. This is an exploratory robustness experiment, not a validated safety monitor.
Version 0.2.2 adds causal patch sweeps, TopK SAE experiments, a Neuronpedia feature lookup and saved attention/feature/graph artifacts. See the evaluations, supported adapters and prioritized roadmap.
| Research workflow | What you can do |
|---|---|
| Activations | Explore layer × token activation magnitudes and next-token predictions. Resident capture reuses the serving model’s weights. |
| Interventions | Scale, ablate, patch or steer a block output; compare with an unchanged baseline. |
| Probes | Train labeled linear probes and inspect held-out metrics alongside control baselines. |
| SAE sandbox | Train small sparse autoencoders; inspect training curves and feature examples. |
| Token analysis | Explore token probabilities and alternatives, compare outputs and reopen saved analyses. |
| Saved studies | Reopen experiment results and settings, rerun configurations, and export measurements with provenance. |
MLX probes, interventions and SAE training use isolated workers and require additional memory. Pool experiments use the resident GGUF model for supported captures and interventions, with probe/SAE fitting on the coordinator. Resident capture still uses GPU capacity and may delay inference. Choose a capture mode →
These are experimental research tools. Activation norms, token probabilities and model-emitted thinking are observations to investigate; they do not certify safety or reveal a faithful account of internal reasoning. Full circuit tracing and pretrained SAE imports are not currently included.
| Workspace | Purpose |
|---|---|
| Lab | Experiments, saved studies and token analysis. |
| Execution | Live request inputs, model-emitted thinking, outputs, tool-call data and errors. |
| Models | Start and stop models, choose Thinking defaults and manage launch settings. |
| Discover | Find and download compatible models from Hugging Face. |
| Router | One OpenAI-compatible endpoint for your tools; optional LAN inference sharing. |
| Pools | Pair a worker, run a supported GGUF across devices and inspect allocations and activity. |
| Performance | Measured throughput, time to first token, GPU activity and memory telemetry. |
| Chat | Try prompts, inspect emitted thinking and continue saved conversations. |
See the native app
Use the Python SDK, HTTP APIs or local MCP bridge to script studies and connect your tools. Start with the interface that fits your workflow:
| Interface | Guide |
|---|---|
| Native app | Install and use every feature |
| Python SDK | Installation, resident capture, jobs and artifacts |
| HTTP API | Inference, research and execution endpoints |
| Local MCP | Connect an assistant over stdio |
| Runtime details | CLI commands, telemetry and architecture |
Prefer GitHub docs? App · SDK · API · MCP · OpenAPI.
Start a model, open Router, enable Share on local network, then start the router and copy its displayed URL into your client. Sharing is opt-in and has no authentication: use a trusted network. Research and execution endpoints remain local-only. Setup and troubleshooting →
Bug reports, research feedback, documentation improvements and focused PRs are welcome. Read CONTRIBUTING.md before starting a substantial change. Report vulnerabilities privately through SECURITY.md.
Build on an Apple Silicon Mac with macOS 14+, the Xcode Swift toolchain and uv:
git clone https://github.com/canivel/dynolab.git
cd dynolab
./app/build.sh
open app/build/Dyno.appThe full build bundles Python and MLX. Use ./app/build.sh --slim for native UI iteration. Local builds default to ad-hoc signing; see the maintainer handbook for Developer ID signing, notarization and release credentials.
uv sync --locked --extra mcp --extra docs --python 3.12
PYTHONPATH=src uv run --frozen python -m unittest discover -s tests -v
uv run --frozen python scripts/check-docs.py
swift test --package-path appPRs require review and passing Python/native checks. Merging runs CI; creating a protected version tag starts the signed release workflow, which creates a draft for verification before publication.
The website is maintained separately and deployed at dynolab.dev. This repository owns the app, SDK, API schema and source documentation.
MIT. Built with SwiftUI, MLX and MLX LM.
A recorded run of Qwen3-235B-A22B Q4_K_M, a 142.2 GB model, across a 128 GiB Mac and a roughly 32 GiB RTX 5090 worker. Native activation, probe and SAE experiments also completed on this pool. CPU output tensors participate; adding the devices' reported headroom does not guarantee a model will fit. Loading this model took about 49 minutes on the tested network. Start with a small GGUF to verify your connection.
Available in 0.3.0, the experimental pool uses a verified local SSH tunnel and keeps raw RPC on loopback. Setup and limitations · Pool API and Python clients · Windows client.
Try the first experiment and tell us where you got stuck. An issue with your app version, model and steps to reproduce is useful even when you are new to interpretability. Please leave credentials and private prompts out of public reports.
If Dyno Lab is useful to you, star the repo to bookmark it and support its development. Reproductions, corrections and focused contributions help turn a personal research tool into something other people can rely on.
An offline probe detected prohibited action proposals, but flagged six legitimate approvals when wording changed. Read the methods, model comparison and false alarms, or view the illustrated research note. The evidence contains all 336 responses and a CPU-only audit. The illustrated grouped-validation workflow uses an unreleased development build, not released 0.4.3.