An operating system
for computer vision.

Supervisely runs on apps: self-contained tools with a Python backend and a web interface. Train neural networks, import any format, automate routine work or build your own labeling tools.

Explore apps Developer portal

400+apps 7M+runs

Models107
Import and export89
Data operations63
Labeling26
Analytics23
Platform and dev tools11

Your app Build one with the Python SDK and a web UI, and run it like the rest.

Most AI software is a product. Supervisely is a platform.

Every computer vision team eventually outgrows hand-made tools. The question is whether its software can grow with it, or whether new needs wait in someone else's backlog.

1 min to start contributing, thanks to App Engine and the developer tools.

~1% of the code is left to write: 10,000+ open-source projects on GitHub are 99% ready.

Supervisely is not the only contributor

Supervisely Platform · exponential growth

Typical AI product Logarithmic growth The bigger the codebase, the harder each new feature.

1 min to start contributing, thanks to App Engine and the developer tools.

~1% of the code is left to write: 10,000+ open-source projects on GitHub are 99% ready.

Not only us. Supervisely is not the only contributor.

Typical AI product. The bigger the codebase, the harder each new feature.

Typical AI product

The curse of the monolith

Supervisely

A platform that grows with you

Too many feature requests for a single development team to implement

Anyone can create and publish Supervisely Apps, not only our team

The product gets overcomplicated with tools that are hard to use

A dozen ways to do the same task is fine: it is just a dozen apps

As functionality grows, it becomes hard to develop and maintain

New features ship as apps that build on existing open-source code

The community has no way to add the things it needs

With App Engine and the developer tools, contributing takes a minute

Customers wait for the vendor and cannot change anything themselves

Customization means building another app, without affecting other users

App Engine turns Python scripts into web apps.

An app is a Git repository with a Python backend, a configuration and a web interface. Supervisely runs it on an agent on any machine and shows its interface in your browser.

In your browser Web interface Built from ready-made Python widgets and shown inside Supervisely, on any PC.
config.json Configuration How to run the app: its Docker image, the start command and where it appears in the platform.
src/main.py Python backend Handles actions from the interface, computes results and updates the UI.
Supervisely Agent Runs on any machine Your GPU server, a cloud VM or a laptop, connected to Supervisely.

Supervisely Agent

Supervisely Agentrunning

GPU 0GPU 1GPU 2GPU 3

src/main.py

import supervisely as sly
from supervisely.app.widgets import Button, Card, Container, Text

api = sly.Api.from_env()
button = Button("Count images")
result = Text()

@button.click
def count_images():
    project = api.project.get_info_by_id(PROJECT_ID)
    result.text = f"{project.items_count} images"

layout = Card("My first app", content=Container([button, result]))
app = sly.Application(layout=layout)

config.json

{
  "name": "My first app",
  "type": "app",
  "categories": ["images", "stats"],
  "entrypoint": "python -m uvicorn src.main:app",
  "docker_image": "supervisely/base-py-sdk",
  "gpu": "preferred"
}

In your browser

My first app Count images 1,284 images

Supervisely Apps open right where you need them.

An app's config.json tells the platform where the app appears. Apps work on the same Supervisely projects, so what one app produces is ready for the next one, with no format conversion.

In a context menu

Run an app from the menu of a project, a dataset, a Team Files folder or a labeling job: export the data, convert its labels or report on the work.
In the labeling toolbox

A panel in the Apps tab of the image or video labeling toolbox. It follows the annotator's work and can suggest labels, check them or open the next image.
Custom labeling UI
On a page of its own

A full interface with its own dashboard for longer jobs, such as training a model, importing data from another source or comparing predictions.

In public or private repositories

Apps made by the Supervisely team are open source on GitHub, so any of them can be forked as a start. On Enterprise Edition, your own apps stay private: connect a private GitHub or GitLab repository, or release from your computer with supervisely release.

The REST API and Python SDK connect Supervisely to your code.

Nearly everything you do in the interface is also available over the HTTP REST API, from any language. The open-source Python SDK wraps that API for scripts, integrations and apps.

REST API

Send requests with your personal API token in the x-api-key header, from any language or tool, and get JSON back. On Enterprise Edition, use your own server address.

API reference
Python SDK

Install it with pip install supervisely. It is open source under Apache 2.0, turns your data and labels into Python objects, handles paging and retries, augments images together with their labels and exports projects to COCO, YOLO or Pascal VOC.

SDK reference Source on GitHub PyPI

Developer portal Get your API token

REST API

# List projects with your API token
curl -H "x-api-key: <your-api-token>" https://app.supervisely.com/public/api/v3/projects.list

Python SDK

import supervisely as sly

# Reads SERVER_ADDRESS and API_TOKEN from the environment
api = sly.Api.from_env()

# A workspace's projects, as Python objects
for info in api.project.get_list(WORKSPACE_ID):
    print(info.name, info.items_count)

# Download a project and convert it to YOLO
sly.download(api, PROJECT_ID, "data/project")
project = sly.Project("data/project", sly.OpenMode.READ)
project.to_yolo(dest_dir="data/yolo")

400+ apps, each one click away.

Train and run neural networks, add models and tools to the labeling toolboxes, import and export any format, and automate routine work, like in a real app store.