Aim Stack is an open source ML experiment tracking and visualization platform that provides a lightweight SDK and Web UI, and supports interactive comparison and search of very large-scale experiments.

AimStack

Core parameters and statistics

Aim Stack (Aim for short) is an open source, self-hosted ML experiment tracking and visualization platform. It was launched by AimStack (the team is located in Armenia) in 2020. Its core positioning is a "lightweight, high-performance, zero database dependency" alternative. While remaining completely open source (Apache 2.0), it provides an interactive visualization experience comparable to the commercial product W&B (Weights & Biases), and all experimental data is stored in the local file system without the need for additional maintenance of database services.

Projects	Aim Stack	MLflow Tracking	TensorBoard	W&B (Weights & Biases)
Open source agreement	Apache 2.0	Apache 2.0	Apache 2.0	Partially open source (core functions closed source)
Deployment method	Self-hosted (pip install)	Self-hosted + managed	Run locally	SaaS + private cloud
Database dependencies	None (local file system)	Backend storage required (SQLite/MySQL/PostgreSQL)	None	Hosting (no user maintenance required)
SDK Languages	Python	Python, R, Java	Python	Python, R
Web UI interactivity	Strong (Comparison, Search Explorers)	Medium (Tables, Charts)	Weak (scalar curves only)	Strong (Dashboards, Reports)
Experimental scale support	10,000-level Run	10,000-level Run	1,000-level Run	10,000-level Run
Enterprise version / Commercial support	No official commercial version (can contact enterprise support)	Yes (Databricks platform)	No	Yes (paid team/Enterprise version)
GitHub Stars	6.2k	19k+	Not applicable (TensorFlow sub-project)	Not applicable (not fully open source)
Data sovereignty	Fully local	Local when self-hosted	Fully local	Data offshore (SaaS)

A brief comment: Aim is an "experiment tracker that does not require a database". For ML teams that focus on data sovereignty and pursue lightweight deployment, it is the strongest open source alternative to the commercial product W&B.

User and market recognition

GitHub community activity: Aim has 6.2k Stars, 401 Forks, 83 contributors on GitHub, and has released a total of 71 Releases. The latest version is v3.29.1 (2025-05-08). The main language of the project is Python (91.8%), supplemented by Cython (4.7%) and JavaScript (1.8%). The community remains active through Discord, Twitter, Medium, and more.

Enterprise adoption status: The official list of specific enterprise customers has not been disclosed, but judging from the "TRUSTED BY ML TEAMS FROM" brand wall displayed on the PyPI page (including the logos of multiple technology companies) and the enterprise support services provided by AimStack (contact via [email protected]), it has been verified by some European and American technology teams.

Academic Citation: Aim has been cited in academic papers (DOI: 10.5281/zenodo.6536395) and is used as a standard tracking tool in experimental replications in the NLP/CV field.

Industry benchmarking evaluation:

• vs TensorBoard: Aim is significantly better than TensorBoard in the interactive comparison of Web UI (multi-experiment overlay, zoom, search) in single-experiment scalar curve viewing capabilities, and supports multi-modal tracking such as images/text/embedding.
• vs MLflow: The advantage of Aim lies in the out-of-box visual experience and zero database architecture; the advantage of MLflow lies in the completeness of the ecosystem (model registration, deployment, serving).
• vs W&B: W&B leads in team collaboration, report sharing, and automated alerts; Aim is open source and free + data sovereignty, making it suitable for budget-sensitive teams.

Community ecological plug-in:

• aimlflow: Provides Aim's powerful UI front-end for MLflow experiments (that is, use Aim's UI to view the data recorded by MLflow).
• Aim-spaCy: spaCy experiment tracker based on Aim, focusing on NLP pipeline experiment management.

Cost advantage

C-side/Personal Cost: Completely free. There are no licensing or subscription fees to pay. Self-hosting has no feature limitations and can be used on any number of project runs.

Developer/Team Cost: Self-hosting costs extremely low. All you need is a Python-enabled machine (or shared storage) and pip install aim. No database operation and maintenance costs - Aim uses local file system (.aim repo) storage and does not introduce external dependencies such as MySQL/PostgreSQL. Compared with MLflow (which requires the configuration of Tracking Server + backend database + artifact store), Aim's operation and maintenance burden is significantly lower.

Business/Privatization Costs: No official commercial pricing available. If an enterprise needs enterprise-level functions such as SSO, RBAC, and SLA, it needs to expand on the open source basis by itself, or contact the AimStack team ([email protected]) to discuss enterprise support. This part of the hidden development cost should be included in the total cost of ownership (TCO) when selecting the model.

Three-tier cost comparison table:

Cost Dimension	Aim Stack	MLflow (self-hosted)	W&B (SaaS)
Software license fee	$0 (Apache 2.0)	$0 (Apache 2.0)	Team version starting from $50/person/month
Database operation and maintenance	No database required	SQLite/MySQL + storage required	Hosting, no operation and maintenance required
Server cost	Single machine required	At least 1 server required	Billed by usage
Learning cost	Low (10 minutes to get started)	Medium (Tracking Server needs to be configured)	Low (SaaS ready to use)
Data migration cost	Low (direct copy of local files)	Medium (tracking store needs to be exported)	High (API export is limited)
Enterprise function expansion cost	High (requires self-development of RBAC/SSO)	Medium (MLflow has community RBAC)	Already included in the enterprise version

The free truth: Aim is completely open source and has no hidden payment points, but the price of "free" is that enterprise-level functions (permission SSO, audit logs) need to be built by yourself; when large-scale teams (>50 people) share the same .aim repo, concurrent reading and writing of the file system may become a bottleneck, and it is necessary to upgrade to remote Tracking Server mode.

Main functions

• Interactive Run Comparison (Explorers): In the Web UI, through multiple visual explorers such as Metrics Explorer, Params Explorer, Scatter Explorer, etc., any number of Runs can be superimposed for indicator curve comparison, hyperparameter scatter analysis, and image sequence playback. Supports mouse hover highlighting, zooming, and area selection, and you can filter abnormal runs without writing code.

  • Synergy: The comparison view can be saved directly as a Dashboard and shared with team members without repeated configuration.

• Full-text search and query: Filter runs by hyperparameter range (learning_rate > 0.001), metric threshold (acc >= 0.9), label or custom context via Aim's Python expression query syntax. Search results are displayed in a sorted table or dashboard, supporting fuzzy matching and range queries.

  • Synergy effect: Search conditions can be saved as "bookmarks" and common queries can be reused with one click, which is suitable for repetitive viewing scenarios such as team weekly reports and model baseline reviews.

• Automatic metadata recording: One-click tracking through SDK - from aim import Run; run = Run() Automatic capture:

  • Contextual information (Python version, system information GPU model)
  • Git commit hashes and branches
  • Custom hyperparameters (dictionary form)
  • Indicator sequence (loss, accuracy, etc., recorded by step)
  • Multi-modal data such as images, text, and embeddings (Run.track())
  • Synergy: Combined with automatic logging + search, teams can find "the highest acc experimental configuration on a certain data set" from thousands of runs in seconds.

• Dashboards: Combine any exploration views (indicator comparison chart, parameter table, picture preview) into a custom dashboard, supporting drag-and-drop layout. Dashboard data is updated automatically as new Run writes.

  • Synergy: The dashboard can be used as an automatically generated page for the "Team Experiment Daily", eliminating the duplication of manual screenshot reporting each time.

• Lightweight deployment and remote tracking:

  • pip install aim single command installation; aim up starts the Web UI with one click (default port 43800).
  • Supports Remote Tracking Server mode: multiple training machines send indicators to the central Aim service, suitable for cluster training scenarios.
  • Supports Kubernetes deployment (official deployment guide is provided).
  • Integrated with Jupyter/Colab to launch Web UI directly within Notebook.
  • Synergy: From stand-alone experiment to team remote collaboration, you only need to change the pointer of the repo parameter in aim.Run(), and the SDK code does not need to be rewritten.

• Ecosystem Expansion:

  • aimlflow: Brings Aim's UI interface to MLflow without losing the model registration and deployment functions of the MLflow ecosystem.
  • Aim-spaCy: Focus on experiment tracking of NLP pipelines.
  • Supports integration with mainstream frameworks such as PyTorch, TensorFlow, Keras, Hugging Face, PyTorch Lightning, and Stable Baselines3.

Model and version evolution

Since its launch in 2020, Aim has undergone a complete evolution from prototype (v1/v2) to production level (v3). The v3 series is the current main version and maintains an iterative rhythm of one minor release every 6-8 weeks.

Key nodes in version evolution:

Version	Release Date	Core Changes
v1.x (initial version)	~2020	First public version, basic experiment tracking capabilities
v2.x	~2022-06	Comprehensive reconstruction, introduction of Explorer system, support for multi-modal tracking
v3.21.0	2024-06	Python 3.12 supports, deletes the entire Experiment, large object remote tracking Jupyter UI embedded
v3.22.0	2024-06	File system-based Artifact Storage
v3.23.0	2024-07	SB3 callback fix, client timeout reduction, CLI skip initialization
v3.24.0	2024-08	Remote batch update UI read-only mode, bookmark scrolling repair
v3.25.0	2024-10	Reports function, self-signed SSL certificate support
v3.25.1	2024-11	Empty index.db handling fix Python 3.12 build fix
v3.26.1	2024-12	Indicator query performance optimization, basic fault diagnosis tools
v3.27.0	2024-12	PyTorch Lightning Logger enhances S3 Artifact Storage, Run status report repair, parallel Tag creation repair
v3.28.0	2025-03	Remove redundant checks to improve performance Hugging Face Distributed Run Callback Tag repeated processing, remote tracking exception handling, code style improvements
v3.29.1 (latest)	2025-05	Unified database reading + constant index to improve query performance min/max Calculation repair Jupyter/Colab integration repair stalled run automatic marking

Version Management Features:

• Aim does not use semver's strict semantic version, and minor version increments correspond to feature sets rather than API compatibility marks.
• The v3.x series maintains backward compatibility, and the same .aim repo can be read by different minor versions of aim SDK.
• The v2.x legacy SDK code has been officially removed ([chore] Remove legacy (aim 2.x.x) sdk in v3.28.0), and users are recommended to upgrade to v3.28+.

Latest version v3.29.1 detailed explanation:

• Query performance revolution: Introducing "single unified database" reading + "constant data index" to reduce the cross-run indicator query delay from second level to sub-second level, which is particularly important for ten thousand-level run scenarios.
• UI/Integration Fixes: Fixed compatibility issues with Web UI embedding in Jupyter/Colab, as well as errors in single-point calculation of min/max for indicators.
• Stability enhancement: Added stalled run to automatically mark finished, use polling observer to ensure immediate detection of file modifications, and automatically roll back when the unified database is abnormal.

Technical advantages

Zero database architecture: Aim does not rely on SQL/NoSQL databases, all tracking data is stored in the .aim repo on the local file system. The data of each run is stored independently in a serialized file (based on Cython-optimized binary format), and SQL-like query capabilities are provided through the UnionDB (unified database) layer. This architecture brings three direct advantages:

1. Zero operation and maintenance: No installation/configuration/tuning of database is required, reducing the complexity of MLOps infrastructure.
2. Portability: .aim repo can be directly copied/compressed/transmitted, and experimental data can be moved with the project.
3. Writing performance: Serialized writing requires no network I/O, suitable for high-frequency indicator recording (once per step).

Cython Core Acceleration: Aim's core storage layer (aim/storage/) is written in Cython (4.7%), achieving performance close to C language in indicator serialization/deserialization and aggregation queries (min/max/mean/count). Compared to pure Python implementations of tracking libraries, Aim has lower latency when processing metric aggregations of 10,000+ Runs.

UnionDB Query Engine: Different from the "index on write" strategy of traditional experiment tracking tools, Aim adopts the UnionDB design of "merge on read". Newly written Run data is immediately visible (no need to wait for index rebuilding), and UnionDB automatically merges all Run storage fragments and performs Python expression filtering when querying. This design performs well under frequent write + frequent query workloads, but it also means that complex cross-run aggregation queries may be slightly slower than pre-indexed databases (such as MLflow's MySQL backend) - this is the direction of Aim's official continuous optimization (v3.29.1 introduces constant indexes for this purpose).

Web UI Performance: The front-end is built based on React + TypeScript, and uses virtual scrolling, on-demand loading of WebSocket and real-time push to ensure smooth browser interaction under 5,000+ Runs and millions of data points. Compared with TensorBoard's single-process Flask architecture, Aim's Web UI has a significantly better experience in multi-experiment comparison scenarios.

Embedding and Integration Strategy: The Aim SDK is designed to be "non-intrusive" - embedding arbitrary Python training scripts via the __setitem__ and track methods of the Run object, without forcing framework callbacks or specific training loop structures. The official provides integration examples for PyTorch, TensorFlow/Keras, Hugging Face, PyTorch Lightning, Stable Baselines3 and other frameworks, as well as an MLflow migration guide.

Technical differences with competing products:

Technical Dimension	Aim Stack	MLflow	W&B
Data storage engine	Cython optimized file format	Relational database	Hosted time series database
Query latency (10,000-level run)	Sub-second level (v3.29+)	Second level (depends on DB performance)	Millisecond level (hosting)
Deployment Dependencies	Python 3.8+	Python + DB + Storage	None (SaaS)
Cross-Run comparison	Native support (Explorer)	Custom query required	Native support
Offline/locally available	Completely offline	Offline available	Internet connection required
Data ownership	100% user-owned	100% when self-hosted	Data via third party

How to use

Situated requirements

• Python 3.8+ (3.10+ recommended)
• pip package manager

Quick Start

Step 1: Installation

pip install aim
# Verify installation
aim version

Step 2: Integrate Aim SDK in the training code

from aim import Run

# Initialize a new Run
run = Run()

# Record hyperparameters
run["hparams"] = {
    "learning_rate": 0.001,
    "batch_size": 32,
    "optimizer": "adam",
    "epochs": 50
}

#Training cycle has a successful record indicator
for epoch in range(50):
    train_loss = train_one_epoch(epoch)
    run.track(train_loss, name="loss", step=epoch, context={"subset": "train"})

    val_acc = validate(epoch)
    run.track(val_acc, name="accuracy", step=epoch, context={"subset": "val"})

Step 3: Start Web UI

aim up
# Open at http://127.0.0.1:43800 by default

Remote tracking mode

When training is running on multiple machines, the Aim remote tracking service can be started:

# Start the tracking service on the central server
aim server --port 43800

# Point to the remote service in the training code
from aim import Run
run = Run(repo="aim://<server-ip>:43800")

Kubernetes deployment

Aim provides the official Kubernetes deployment guide. Typical configuration includes:

• aim server Deployment (central tracking service)
• PersistentVolume (experimental data persistence)
• Service (internal communication)

View documentation and examples

• Official documentation: https://aimstack.readthedocs.io/
• Code examples: https://github.com/aimhubio/aim/tree/main/examples
• Migration Guide: Supports migration from MLflow, TensorBoard and other tools to Aim

Use entrance control

Entrance	Applicable scenarios	Startup method
Web UI	Full-featured visualization, comparison, search	aim up
Python SDK	Embed tracking in training scripts	import aim
Remote Server	Multi-machine cluster unified tracking	aim server
Jupyter/Colab	Experiment management in Notebook	aim up --notebook
CLI	Query, statistics, management repo	aim status/repo/version
Python API	Programmed query and analysis	from aim.sdk import Repo

Product Pricing

Aim's core product adopts the Apache 2.0 open source license and is completely free. There is no functionally stripped community version or paid professional version. All users have access to full functionality upon installation, including multi-explorers, dashboards, remote tracking and full-text search.

Free quota details:

• No limit on the number of runs
• No limit on the number of users
• No limit on the number of indicators
• No storage capacity limit (limited only by local disk)

AimStack Enterprise Support: The AimStack team provides enterprise-level support services through [email protected], including but not limited to:

• Priority technical support (SLA)
• Customized function development
• Privatization deployment consulting -Team training and onboarding

Pricing is not disclosed, please contact AimStack for a quote. For teams that require enterprise-level functions such as SSO, RBAC, and audit logs, Aim currently does not officially provide built-in implementations, and they need to expand or integrate third-party identity providers on an open source basis.

Hidden Cost Tip:

• For large teams (>20 people), it is recommended to use Remote Tracking Server mode, which requires an additional server resource.
• The development and maintenance time cost of custom enterprise functions (authorized SSO) should be included in the evaluation during selection.
• Integration with existing MLOps pipelines (Kubeflow, Airflow) may require additional adaptation development.

Application scenarios

• Personal ML project experiment management: replace local scattered CSV/Excel/screenshot records. Automatically capture the hyperparameters, indicator curves, and system resource usage of each training, and make them clear at a glance through the Web UI. Deduction benefits: Manual recording (about 15 minutes per experiment) is reduced to automatic recording (zero additional time), and historical experiments can be searched and traced back, avoiding the pain point of "I remember that I ran good results last time but couldn't find the configuration."

• Internal team model benchmarking (Benchmarking): Team members record their own experiments on shared storage or the central Aim Server, and quickly find the current best practice hyperparameter combination through search and comparison. Deduction benefits: From "WeChat/email screenshot + verbal communication" (about 2-4 hours of alignment cost per week) to "Open Aim Dashboard to see at a glance" (about 10 minutes per week). Combined with the bookmark function, there is no need to take repeated screenshots of weekly reports/reviews.

• Open source self-hosted MLOps infrastructure: Embed Aim as a lightweight experiment tracking component into an existing self-built MLOps stack. Suitable for teams that already use orchestration tools such as Kubeflow and Airflow - Aim's zero database dependency feature makes it easy to integrate with existing architectures without increasing operation and maintenance complexity. Deduction benefits: Compared with the introduction of MLflow (which requires additional Tracking Server + DB), the integration time of Aim is shortened from about 2 days to about 2 hours.

• Jupyter Notebook interactive experiment: Data scientists complete one-stop experiments of data cleaning, feature engineering, and model training in Notebook, and use aim up --notebook to view indicator changes in real time in the Notebook embedded UI. Deduction benefits: From "repeated print loss + matplotlib plotting" (about 30 seconds of manual operation per epoch) to "automatic tracking + real-time curve" (zero extra operations).

• Academic research and paper reproduction: The researcher incorporated Aim into the experimental process and automatically recorded the results of each hyperparameter adjustment. Aim's academic citation support (CITATION.cff) standardizes the citation of experimental data in papers. Deduction benefits: From "looking through logs when the paper review requires supplementing experimental details" (about 1-3 days of backtracking time) to "directly sharing the .aim repo path" (immediately).

Applicable people

Suitable for the crowd:

• Independent ML Developer/Freelance: Need a free, maintenance-free, full-featured experiment management tool. Aim's zero-database architecture means you can run a complete workflow on a single laptop, making it suitable for personal projects and cost-conscious Freelancers.

• Small to medium ML team (5-50 people): The team needs to share experimental information but the budget is not enough to purchase commercial SaaS such as W&B. Aim's self-hosting capabilities and easy deployment allow teams to quickly set up an experiment tracking center on a shared server without the need for a dedicated MLOps engineer.

• Organizations that focus on data sovereignty and compliance: ML teams in finance, medical, government and other industries are unable to use SaaS solutions due to compliance requirements (such as GDPR, HIPAA, data not exported abroad). Aim's fully localized storage feature makes it the preferred open source solution for compliance scenarios.

• MLOps Platform Builder: When building an internal MLOps platform, a lightweight embeddable experiment tracking component is required. Aim's Python SDK and UnionDB query interface facilitate the integration of upper-level orchestration systems.

Not suitable for the crowd/scenario of persuading people to quit:

• Teams requiring enterprise-level permission management: Aim currently does not have built-in RBAC/SSO. If the team needs fine-grained experimental access control (such as "only seniors are allowed to delete Run"), they need to develop it on an open source basis or add a proxy layer on top of Aim. It is recommended that this type of needs should be prioritized to evaluate MLflow (with community RBAC scheme) or W&B (built-in enterprise permissions).

• Very large-scale teams (100+ people): Although Aim can handle tens of thousands of runs, file lock competition may occur when multiple people write to the same .aim repo at the same time. The official recommendation is to use Remote Tracking Server for mitigation, but there is no benchmark for W&B's team collaboration functions (such as experiment comments, approval flow).

• Organizations needing one-click hosted SaaS: Aim is a self-hosted plan and does not offer out-of-the-box SaaS like W&B. If the team doesn't want to maintain any infrastructure, Aim is not the right option.

• Non-Python stack team: Aim SDK only supports Python. If the team mainly uses R, Julia or Java to train the model, an additional encapsulation layer is required.

Summary and Outlook

Core Competencies: Aim has formed a differentiated positioning in the open source ML experiment tracking track with "zero database dependency + interactive Web UI + 10,000-level run performance". Compared with TensorBoard's visual simplicity and MLflow's deployment complexity, Aim has achieved the ultimate in "quickly obtaining a good-looking experiment dashboard" - from pip install to aim up, you can have an interactive experiment management interface within 10 minutes. For teams that are sensitive to data sovereignty, have limited budgets, and are pursuing a lightweight MLOps stack, Aim is currently the most balanced open source choice.

Current limitations: The lack of enterprise-level features (authorized SSO, audit logs) and commercial support are Aim's main shortcomings in competing with W&B/Neptune. In addition, Aim's ecosystem breadth (number of integrations, community plug-ins) is still far less than MLflow. In scenarios that require model registration and deployment of Serving full links, Aim needs to be used in combination with other tools.

Procurement/Adoption Risk Assessment:

• Technical Risk: Low. Aim has the lightest deployment complexity among similar tools and low migration costs (you can try it with pip install, and you can uninstall it at any time if you are not satisfied. The experimental data exists in the .aim directory and can be kept or deleted).
• Supplier Risk: Medium. The size of the core maintenance team is limited (about 10 active contributors on GitHub), and the long-term sustainability of the project depends on community activity and the commercialization progress of AimStack. It is recommended to at least pay attention to issue response speed and Release frequency as health indicators.
• Compliance Risk: Low. The data is completely localized and no third-party data transfer is involved.

Follow-up observation points:

1. Dashboard customizable layouts: "customizable layouts with embedded explorers" in the official roadmap will bring Aim's dashboard capabilities close to W&B levels and are worth tracking.
2. Text Explorer: used for experimental comparison of Prompt engineering scenarios, which is valuable to LLM application developers.
3. Commercialization Progress: Whether AimStack will launch a paid enterprise version (including SSO/RBAC) will directly affect the adoption rate of Aim in large organizations.
4. MLflow Ecological Integration: The development direction of aimlflow (whether it is an independent tool or is absorbed into the core of Aim) will affect the user's selection decision of "MLflow vs Aim".

Recommendation: Start connecting with individual or group projects, and then consider in-depth integration with existing pipelines after confirming that the tracking granularity and search experience meet your needs. For scenarios where enterprise-level permissions and SSO are required, it is recommended to pay attention to AimStack’s enterprise support updates or reserve a budget for self-built expansion.

Related tools: hugging-face, replicate

Version Info

• Aim v3 ：There is no official precise date yet. （2025-12）
• Aim v2 ：There is no official precise date yet. （~2023-06）