An open-source AI laboratory for building, training, and deploying machine learning models.
Powered by Kubernetes.

Status	Badge	Status	Badge
Build		Docker
License		Platform
Issues		Closed Issues
Pull Requests		Last Commit
Top Language		Code Size
Repo Size		Contributors
Stars		Forks
Rust		Axum
Next.js		React
TypeScript		Python
PostgreSQL		Kubernetes
PyTorch		Docker
shadcn/ui		GraphQL
Playwright		PRs Welcome
Discord

Features

For Data Scientists

• Project Management -- Organize experiments with stage-based workflow (Ideation, Development, Production)
• Project-Scoped Filtering -- Global project selector in the topbar scopes every page (models, datasets, experiments, jobs, workspaces, features, visualizations) to a single project
• Model Editor -- Write and edit models directly in the browser with Monaco (Python + Rust)
• Model Registry & CLI -- Search, install, and manage models from the Open Model Registry via CLI (openmodelstudio install iris-svm) or the in-app registry browser. Install status syncs bidirectionally between CLI and UI
• Real-Time Training -- Watch loss curves, accuracy, and all metrics auto-update live during training with second-level duration accuracy
• Generative Output Viewer -- See video/image/audio outputs as models train
• Experiment Tracking -- Compare runs with parallel coordinates and sortable tables
• Visualizations & Dashboards -- 9 visualization backends (matplotlib, seaborn, plotly, bokeh, altair, plotnine, datashader, networkx, geopandas) with a unified render() abstraction. Combine visualizations into drag-and-drop dashboards with persistent layout
• Global Search -- Cmd+K command palette searches across models, datasets, experiments, training jobs, projects, and visualizations with instant navigation
• Notifications -- Real-time notification bell with unread count, grouped timeline (Today / This Week / Earlier), mark-all-read, and context-aware icons
• JupyterLab Workspaces -- Launch cloud-native notebooks pre-loaded with tutorial notebooks (Welcome, Visualizations, Registry)
• LLM Assistant -- Natural language control of the entire platform
• AutoML -- Automated hyperparameter search
• Feature Store -- Reusable features across projects

For ML Engineers

• Kubernetes-Native -- Every model trains in its own ephemeral pod
• Rust API -- High-performance backend built with Axum + SQLx
• Python SDK & CLI -- pip install openmodelstudio gives you both a Python SDK (import openmodelstudio as oms) and a CLI for registry management, model install/uninstall, and configuration
• GraphQL -- Auto-generated from PostgreSQL via PostGraphile
• Streaming Data -- Never load full datasets to disk
• One-Command Deploy -- make k8s-deploy sets up everything

For Researchers

• HARPA Architecture -- Novel hierarchical adaptive recurrent model included
• Genie World Model -- Interactive video generation from unlabeled video
• Video-JEPA -- Self-supervised video representation learning
• TRM -- Tiny recursive reasoning model (7M params, recursion-as-depth)
• Video Generation Pipeline -- End-to-end video+audio dataset processing
• PyTorch + Rust-Torch -- Write models in either language
• Consumer Hardware -- Designed to train on laptops, not GPU clusters

Visualizations & Dashboards

Create, render, and publish data visualizations from notebooks or the in-browser editor. OpenModelStudio supports 9 visualization backends with a unified render() function that auto-detects the library:

Combine visualizations into drag-and-drop dashboards with resizable panels, lock/unlock layout, and persistent configuration. Each visualization also has a full in-browser editor with Monaco, live preview for JSON backends, template insertion, and data/config tabs. See the Visualizations Guide for SDK usage.

Individual Visualization Editor

Dashboard

Model Registry

Browse, install, and manage models from the Open Model Registry -- a public GitHub repo that acts as a decentralized model package manager.

From the CLI:

openmodelstudio search classification        # Search by keyword
openmodelstudio install iris-svm             # Install a model
openmodelstudio list                         # List installed models

From notebooks or scripts, use oms.use_model("iris-svm") to load an installed model, then register and train it with the SDK. Works inside workspace containers via the platform API — no filesystem access needed. Install status syncs bidirectionally between CLI and UI. See the Registry Guide for full SDK usage.

Quick Start

Prerequisites

One-Command Setup

This will:

1. Tear down any existing cluster (clean slate)
2. Build all Docker images (API, Frontend, PostGraphile, Model Runners)
3. Create a Kind cluster
4. Deploy PostgreSQL, API, Frontend, PostGraphile, JupyterHub
5. Run database schema and seed data
6. Health check all services

Access

Default Credentials

Architecture

Components

Training Job Lifecycle

User clicks "Train" --> API creates training_job record
                    --> API creates K8s Job with model code + config
                    --> Pod starts, loads data via streaming
                    --> Pod reports metrics via HTTP --> API stores + relays via SSE
                    --> Frontend receives SSE --> Updates charts in real-time
                    --> Pod completes --> Saves model artifacts
                    --> API updates training_job status --> Frontend shows results

Database Schema (Key Tables)

users            (id, email, name, password_hash, role, created_at)
projects         (id, name, description, stage, owner_id, created_at)
models           (id, project_id, name, framework, registry_name, created_at)
model_versions   (id, model_id, version, code, created_at)
jobs             (id, project_id, model_id, job_type, status, config, metrics, started_at, completed_at)
datasets         (id, project_id, name, path, format, size_bytes, created_at)
experiments      (id, project_id, name, description, created_at)
experiment_runs  (id, experiment_id, parameters, metrics, created_at)
workspaces       (id, user_id, status, jupyter_url, created_at)
visualizations   (id, project_id, name, backend, code, output_type, output_data, published, created_at)
dashboards       (id, project_id, name, description, layout, created_at)
notifications    (id, user_id, title, message, notification_type, read, link, created_at)

See docs/ARCHITECTURE.md for the full architecture documentation.

Tutorial

Follow these guides to go from zero to a fully tracked ML experiment:

1. Usage Guide -- Log in, create a project, upload a dataset, launch a workspace
2. Modeling Guide -- Train, evaluate, and track models using the SDK (16-cell notebook walkthrough including visualizations and dashboards)
3. Visualization Guide -- All 9 backends, render() function, dashboards, and the in-browser editor (pre-loaded as visualization.ipynb in workspaces)
4. Registry & CLI Guide -- Install, use, and manage models from the Open Model Registry (pre-loaded as registry.ipynb in workspaces)

REST API Reference

Authentication

Projects

Models

Training

Visualizations & Dashboards

Notifications & Search

Model Registry

Other Endpoints

GraphQL (port 31002)

Auto-generated from PostgreSQL schema via PostGraphile. Explore at /graphiql.

Environment Variables

Development

Local Development

make dev           # Starts Postgres via Docker, prints instructions for API + Frontend
make dev-api       # Run Rust API locally on :8080
make dev-frontend  # Run Next.js frontend locally on :3000

Run Tests

make test          # API + Frontend tests
make test-api      # Rust API tests only
make test-e2e      # Playwright E2E tests
make test-all      # Everything (unit + e2e + models + pipelines)

Makefile Targets

Run make help to see all available targets. Key ones:

Documentation

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

GPL License