uPyPi: A PyPI-like MicroPython Package Repository

[leezisheng]

uPyPi: A PyPI-like MicroPython Package Repository
uPyPi is a dedicated package management hub for the MicroPython ecosystem, designed to simplify the discovery, sharing, and deployment of MicroPython libraries and drivers.

1. Core Features
   (1) Package Management: A PyPI-inspired repository where you can upload, browse, download, and manage your MicroPython packages.
   (2) JSON Metadata Parsing: All packages require a package.json file to define essential metadata (e.g., name, version), ensuring consistency and compatibility.
   (3) Bilingual Support: Full Chinese/English interface toggle for global accessibility.
   (4) Chip & Firmware Filtering: Discover packages tailored to specific hardware (e.g., RP2040) and firmware environments.
   (5) Personal Dashboard: Track and manage all your uploaded packages in one place, with a clear overview of your contributions.

2. What's New in v0.3.1
   (1) Streamlined UI: Removed redundant code and controls for a cleaner, more intuitive front-end.
   (2) Backend Optimization: Refactored the database, added LRU cache for performance, and removed unnecessary TXT columns.
   (3) Enhanced Development Support: Restored sandbox support, added containerization and local development modes, and decoupled GitHub integration (now only required for development).

Platform URL: https://upypi.net/
User Guide: https://f1829ryac0m.feishu.cn/wiki/L9AlwY1MEiVHQMk19Q7cYb3Hnwh?from=from_copylink

[pi-mst]

Looks a lot like mim!

[peterhinch]

The user guide is in Chinese.

The GitHub button on the application's home page asks for permission to access my own repositories. In the absence of an English language explanation I find that alarming.

[leezisheng]

English User Guide：https://f1829ryac0m.feishu.cn/wiki/WZtiwbHVjirCc1k6Z3ZcSjF2nvb

Hi Peter,
Thanks for your feedback and for taking the time to check out our project.
We are a team of Chinese student electronics DIY enthusiasts working on this open-source project. We completely understand your concerns and have already addressed them:
English User Guide: We've added a complete English version of the user guide, which you can find here: https://f1829ryac0m.feishu.cn/wiki/WZtiwbHVjirCc1k6Z3ZcSjF2nvb
GitHub Permission Request: The GitHub button on the homepage is designed to let users publish their own MicroPython packages directly to our repository. The permission request is only for accessing your own repositories, and this is a standard OAuth flow. Our project is fully open-source, and you can review the code and security practices in our GitHub repo: https://github.com/FreakStudioCN/upypi
We greatly value the trust of the MicroPython community and are committed to making this project as transparent and accessible as possible. Please let us know if you have any further questions or concerns.

[mattytrentini]

So, mip allows installation directly from GitHub or GitLab. It doesn't support versions but the typical workaround for that is to include a submodule in your own repository and add it to a manifest.

mim indexes libraries that are mip-installable so they're easy to find.

I don't want to be discouraging to your work, but it's not clear what benefit there is to creating a package repository?

[leezisheng]

Hi mattytrentini,
Thanks so much for your honest and valuable feedback — we really appreciate you taking the time to share your thoughts!
To address your questions clearly:
When we first initiated the uPyPi project, we were not aware of the mim project. We built this platform purely out of the practical needs we observed in the MicroPython community, especially within the Chinese developer circle.
For developers in China, accessing external code repositories like GitHub or GitLab requires a VPN, which often leads to unstable connections, slow download speeds, or even access failures. This makes it very inconvenient to use mim (which relies entirely on GitHub/GitLab URLs) to install or submit packages.
Additionally, mim only supports indexing packages via repository URLs and does not allow direct file uploads. We designed uPyPi to fill this gap — it enables developers to upload MicroPython package files directly, and also optimizes the access experience for Chinese users.
Our goal is not to compete with mim, but to complement the MicroPython ecosystem. We hope uPyPi can provide a more convenient package management option for developers in Chinese-speaking regions (and global developers who need direct file upload functionality), while also contributing to the diversity of the MicroPython community.
We welcome any further suggestions you may have — your insights will help us improve uPyPi to better serve the entire community!
Best regards,leezisheng

[peterhinch]

Thank you for providing English language docs. The following comments are intended as general information for potential users.

I see that uPyPi uses mpremote mip install - this can already be used to install user-contributed packages from GitHub, e.g.:

$ mpremote mip install "github:peterhinch/micropython-nano-gui/drivers/st7789"

The key aim of uPyPi seems to be to encourage developers to re-publish their packages to a Chinese server, to enable easier access from within China.

[leezisheng]

Thanks for pointing this out! You’re absolutely right. We’ve added chip/firmware filtering (e.g., RP2040) and a full English/Chinese interface toggle, making uPyPi accessible to global users as well. At the same time, we’re advancing the open-sourcing of circuit designs and validation of chip drivers. All chip drivers hosted on uPyPi have undergone rigorous verification, accompanied by detailed documentation covering chip registers and usage instructions. By June this year, we will complete the validation and optimization of over 200 chip drivers. All circuit designs will be open-sourced on the JLCPCB Open Source Platform. Our developers can directly place orders and integrate integrated circuits with one click, enabling the production of a physical prototype in just 3 days.

[leezisheng]

Core Features of the uPyPi Upgrade

1. Bilingual Interface (Chinese / English)

• Supports one-click switching between Chinese and English interfaces.
• Improves accessibility for both domestic and international developers.

2. Special Package Identification

• Implements specialized identification for:
  • Firmware models
  • Hardware-specific packages
• Enhances compatibility matching and reduces misuse of packages.

3. Intelligent Cache Strategy Optimization

• Initially adopts LRU (Least Recently Used) caching to quickly improve baseline performance.
• Evolves to a PostgreSQL-inspired design, switching to Linux PageCache strategy:
  • Balances performance and system compatibility
  • Improves I/O efficiency
• Achieves significantly faster query and download speeds compared to similar platforms (e.g., mim without optimization).

4. Bulk High-Speed Upload

• Supports batch package uploads using ZIP format.
• Improves upload efficiency by dozens of times compared to single-file uploads.
• Solves the problem of slow and tedious uploads, especially for:
  • Driver libraries
  • Large-scale package releases

5. Precise & Efficient Search

• Introduces optimized APIs focused on search functionality.
• Prioritizes and accelerates search endpoints.
• Provides:
  • More accurate results
  • Faster response times
• Enables strong support for IDE plugin integration.

6. Lightweight Development Environment

• Provides:
  • Containerized development environment
  • Local development mode
  • Restored sandbox support
• Eliminates complex environment setup requirements.
• GitHub binding is only required during development:
  • No mandatory platform dependency after deployment
  • Reduces development and debugging barriers

[leezisheng]

About How to use:

Instructions for Downloading and Uploading Driver Packages on the uPyPi Platform

1. Project Background

In the early days of the MicroPython ecosystem, when developers shared or used third-party libraries, they often had to manually download multiple files and then copy them into the project directory. This "copy-and-paste" approach has many pain points:

• Files are easily overlooked, leading to program errors
• Version chaos, not knowing which version of the library is being used
• Dependency management is troublesome, requiring users to find all dependency files themselves
• When sharing with others, all files need to be packaged, which involves cumbersome steps

Later, the MicroPython community introduced the mip (mip installs packages) tool, similar to pip in Python, which can automatically download and manage packages. However, the default index is micropython-lib, and the publication and discovery of third-party libraries are still not convenient enough.

Package platforms similar to PyPI for MicroPython include mim and awesome-micropython, but they all have relatively significant issues:

Thus,** uPyPi (https://upypi.net/) ** came into being —— it is a package management repository specifically designed for MicroPython, like the "PyPI for MicroPython", enabling developers to easily upload, share, and discover driver packages, completely resolving the early library management challenges.

Core issues of the mim platform:

• Version management mechanism: Lacks the function of package version freezing, lacks basic capabilities such as version locking and dependency version constraints, and cannot guarantee the long-term availability of packages and the stability of dependencies.
• Uncontrollable dependency maintenance risk: The availability of packages completely depends on the maintenance status of the original developer. If the developer stops maintaining, upgrading the project, or deletes the repository, the links of the included packages will directly become invalid, downstream projects will be affected in a chain reaction, and the platform has no fallback or migration mechanism.
• Limited verification scope: Only the mip installability of the submitted package is verified, without covering core risk points such as version compatibility, long-term maintainability, and API stability.

Core issues of the mim platform:

• Version management mechanism: Lacks the function of package version freezing, lacks basic capabilities such as version locking and dependency version constraints, and cannot guarantee the long-term availability of packages and the stability of dependencies.
• Uncontrollable dependency maintenance risk: The availability of packages completely depends on the maintenance status of the original developer. If the developer stops maintaining, upgrading the project, or deletes the repository, the links of the included packages will directly become invalid, downstream projects will be affected in a chain reaction, and the platform has no fallback or migration mechanism.
• Limited verification scope: Only the mip installability of the submitted package is verified, without covering core risk points such as version compatibility, long-term maintainability, and API stability.

Core issues of the awesome-micropython project:

• It is merely an index collection without verification capabilities: essentially a linked index list of drivers and libraries, with no validation processes for effectiveness, compatibility, or security established, and unable to guarantee the actual usability of the included content.
• Version compatibility is severely lagging: A large number of included drivers are developed based on MicroPython v1.19, while the current MicroPython has been iterated to v1.27+, with multiple changes in the core API, resulting in the inability of older drivers to run properly in the new version environment.
• Insufficient information transparency: Key information such as the maintenance status of the library and the range of compatible versions is not marked, making it difficult for users to anticipate compatibility issues during use and prone to situations such as code errors and function failures.

2. What benefits can uPyPi bring?

Using uPyPi to manage driver packages has these core advantages:

• ✅ One-click Installation: Users can automatically download and install the package and all its dependencies with just one line of command, without manually copying files.
• ✅ Version Controllable: Specific versions of packages can be specified for installation to avoid version conflicts.
• ✅ ** Automatic Dependency Management **: The tool will automatically resolve and download dependencies, eliminating the need to search for files manually.
• ✅ Easy Sharing: After uploading to uPyPi, developers worldwide can easily find and use your driver package.
• ✅ Easy to update: When there is an update for the package, users only need to re-execute the installation command to obtain the latest version.

**Simply put, the uPyPi platform is the "distribution center" for MicroPython driver packages, where we can search for, view, download, and upload the required driver packages. **

Core features include:

• PyPI-like Package Management System: Supports uploading, browsing, downloading, and full lifecycle management of MicroPython packages, and adapts to the package management needs of the MicroPython ecosystem.
• Standardized metadata management and control: Packages are required to include a package.json file, which uniformly defines core metadata such as name and version to ensure the consistency and compatibility of packages.
• Precise hardware/firmware adaptation: Supports filtering and adapting packages by hardware model (e.g., RP2040) and firmware environment, resolving adaptation challenges in different hardware/version environments.
• Multilingual and Visualization Management: Provides one-click switching between Chinese and English bilingual interfaces; the personal dashboard enables one-stop tracking and management of uploaded packages, clearly displaying contribution data.

Other features include:

• Intelligent caching strategy optimization: First, quickly improve basic performance through LRU caching, then switch to the Linux PageCache solution with reference to the design concept of PostgreSQL, taking into account both performance and system compatibility. Compared with similar platforms (such as mim without performance optimization), the query/download response speed has been significantly improved.
• Batch Rapid Upload: Supports batch upload packages in ZIP format, with upload speed increased to dozens of times the original, solving the problems of cumbersome and time-consuming single-file uploads, and is especially suitable for batch release scenarios of a large number of drivers/libraries.
• Precise and Efficient Retrieval: New API support is added, with a focus on optimizing the search endpoint, resulting in more precise retrieval results, faster response times, and being friendly to IDE plugin extensions.
• Lightweight Development Environment: New containerized solutions and local development mode have been added, sandbox support has been restored, allowing development to be carried out without complex environment configuration; only the development phase requires binding to GitHub, with no mandatory platform binding after going live, reducing the threshold for development/debugging.

3. Quickly Install the Driver Package

If you're new to the MicroPython and uPyPi platforms, don't worry! This guide will start from ** the most basic preparations ** and teach you step by step how to download and use driver packages from the uPyPi platform on Raspberry Pi Pico2 (without network) and Pico2W (with network), using bmp280_driver as an example for the barometric temperature sensor driver. It will also briefly introduce how to upload driver packages (for users with sharing needs).

3.1 Preparatory Work for Beginners with No Prior Knowledge

Before using uPyPi, it is necessary to prepare the hardware, software, and complete the basic settings, all of which are indispensable.

3.1.1 Hardware Preparation

3.1.2 Software Preparation

1. Install Thonny Editor:

Thonny is the most suitable MicroPython development tool for beginners, supporting code writing, development board connection, and file management.

• Download Link:https://thonny.org/
• Installation method: Simply follow the system prompts and click "Next" to install (default settings do not need to be modified).

1. Install the mpremote tool (computer side)

This is a tool for communication between a computer and a MicroPython development board, used for ** locally installing driver packages ** ( ** essential for single-chip microcomputers without network connectivity ** ).

Open the "Command Prompt (CMD)" or "PowerShell" on your computer, enter the following command, and press Enter:

pip install mpremote

The prompt "Successfully installed mpremote" indicates successful installation.

3.2 Development Board Basic Settings (Flashing MicroPython Firmware)

You need to first flash an mpy firmware to your MCU. Here we take Raspberry Pi Pico2 / Pico2W as an example, which comes without a MicroPython firmware out of the box and needs to be flashed first before use.

1. Press and hold the BOOTSEL button on the development board, then connect the development board to the computer using a USB-C cable, and release the button.

2. The computer will recognize a USB drive named "RPI-RP2".

3. Open the browser and download the corresponding firmware:

   • Raspberry Pi Pico2 Firmware: https://micropython.org/download/RPI_PICO2/
   • Raspberry Pi Pico2W Firmware: https://micropython.org/download/RPI_PICO2W/

4. Copy and paste the downloaded .uf2 firmware file **to the **「RPI-RP2」USB drive.

5. After the copying is completed, the development board will automatically restart, the USB drive will disappear, and at this point, the firmware flashing is completed.

3.3 Open the uPyPi platform to search for packages and copy commands

The uPyPi platform is the "hub" for MicroPython driver packages, where we can search for, view, and download the required driver packages.

Open your browser and visit the official uPyPi website:https://upypi.net/

Enter ** bmp280 ** in the search box at the top of the page, then click the "Search" button on the right:

Search results will display matching driver packages (such as bmp280_driver 1.0.0), including two core buttons:

• "View Details": View the description, author, and installation command of the driver package.
• "Download": Manually download the source code of the driver package (for backup, generally not needed).

Click "View Details" to enter the driver package details page, where you can switch driver package versions on the right side of the page:

The left side of the page will display ** core installation commands ** (local installation / remote installation):

3.4 Download and Install the Driver Package

Depending on whether the development board has network connectivity, it is divided into** local installation (Pico2)** and** remote installation (Pico2W)** two methods.

3.4.1 Local Installation (for development boards without WiFi)

Connect to the computer via USB and use the mpremote tool to install the driver package from uPyPi onto the development board.

Enter execution command:

mpremote mip install https://upypi.net/pkgs/bmp280_driver/1.0.0

Wait for the command to execute. When the following content appears in the terminal, the installation is successful:

We can also use the following command to check the files inside the board and confirm whether the download was successful:

# List the root file directory
mpremote fs ls
# List the directory under the 'lib/' folder
mpremote fs ls 'lib/'

3.4.2 Remote Installation (for development boards with WiFi)

First, connect the development board to WiFi, then directly install the driver package in the REPL terminal of the development board.

• First, connect the Raspberry Pi Pico2W to your computer using a USB cable. After Thonny automatically recognizes it, click on the "Shell" panel at the bottom.
• If the Shell panel displays >>> , it indicates that you have entered the MicroPython REPL interactive mode; if it displays other content, press "Ctrl + D" to restart the development board, and you will see >>> .

After the >>> in the Shell panel, enter the following code line by line (replace with your WiFi name and password), and press Enter after each line:

import network
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("Your WiFi Name", "Your WiFi Password")
# Wait for the WiFi connection to succeed
import time
while not wlan.isconnected():
    print("Connecting to WIFI...")
    time.sleep(1)
print("WIFI Connected! IP Address:", wlan.ifconfig()[0])

If it shows "WIFI Connected! IP Address: 192.168.xx.xx", it indicates that the WiFi connection is successful:

After >>> in the Shell panel, enter the following ** complete installation command: **

import mip
mip.install("https://upypi.net/pkgs/bmp280_driver/1.0.0")

After execution is completed, the following display indicates successful installation:

Click "Raspberry Pi Pico2" in the left "File" panel, expand the "lib" folder, if you can see the bmp280_float.py file, it means the installation is successful:

3.5 Use the installed driver package

After the installation is complete, we use the BMP280 sensor to test whether the driver package can work properly. You can refer to the following cloud document for this part:

https://freakstudio.cn/node/019ba20b-b702-7118-a3b3-c3fb7218fd61

4. Upload Driver Packages (Advanced: For Users Who Want to Share Drivers)

If you have developed your own MicroPython driver and would like to share it on uPyPi for others to use, you can follow these steps (using bmp280_driver as an example).

4.1 Prepare a compliant driver package file

The file directory of the driver package must follow the following structure (refer to Figure 6-9), and all components are indispensable:

Your driver package folder (e.g., bmp280_driver)/
├── code/                  # Folder for core driver code
│   ├── core_driver_file.py (e.g., bmp280_float.py)
│   └── test_example_file.py (e.g., main.py, optional)
├── package.json           # "ID card" of the driver package (required file)
├── README.md              # Driver usage instructions (recommended file)
└── LICENSE                # Open source license file (recommended file)

package.json is the core configuration of the driver package and must contain the following required fields, and optional fields can be added to enrich the information:

{
  "name": "bmp280_driver",  // Package name, lowercase, separated by underscores
  "version": "1.0.0",       // Version number, following Major.Minor.Patch rules
  "urls": [                 // File mapping: ["device-side filename", "local file path"]
    ["bmp280_float.py", "code/bmp280_float.py"]
  ],
  "description": "MicroPython driver for controlling the BMP280 pressure and temperature sensor",  // Optional: Function description
  "author": "Your Name",     // Optional: Author
  "license": "MIT",         // Optional: Open source license
  "keywords": ["micropython", "bmp280", "sensor"]  // Optional: Search keywords
}

4.2 Upload the driver package to uPyPi

Ensure that your project's root directory contains the following files (without nested folders, directly placed in the root directory):

• code/: Driver code folder
• LICENSE: License File
• package.json: Package configuration file (must contain name and version fields)
• README.md: Package Documentation

⚠️ Key Requirement: The Compressed Packet must not contain nested additional folders, and all files should be directly under the root directory of the Compressed Packet (refer to the example structure: BH1750_driver.zip → directly contains code/, package.json, etc.).

Next, package the library files into a Compressed Packet:

1. Select all files under the root directory of the selected project (code/, LICENSE, package.json, README.md).

2. Right-click → Select "7-Zip" → "Add to Compressed Packet" (or directly select "Add to [Package Name].zip").

3. In the compression settings:

   • Compression Format Selection zip
   • It is recommended that the file name be consistent with the package name (e.g., BH1750_driver.zip)
   • Confirm** that the path mode is "Relative Path"** to avoid generating nested directories

4. After generating the Compressed Packet, check its internal structure: open the ZIP to confirm that all files are directly in the root directory without additional folder nesting.

Visit the official uPyPi website, click on "Log in with GitHub" in the top right corner, and authorize to log in using your GitHub account:

After logging in, click on "My Panel" at the top, then click on "Click Here to Upload the First Compressed Packet":

Go to the upload page, click "Select File", and select the ZIP Compressed Packet generated just now:

After confirming that the folder contains package.json, click the "Upload Package" button and wait for the upload to complete:

After successful upload, your driver package will be searchable on uPyPi, and other users can install it directly.

4.3 Frequently Asked Questions - Avoiding Version Conflicts and Package Name Duplication

When uploading a driver package to uPyPi, you may encounter a prompt like the one shown in the picture:** "Package bmp280_driver version 1.0.0 already exists." ** This is because the uPyPi platform has strict rules for package management to ensure that each package's version and name are unique, facilitating users to accurately install and use packages.

uPyPi does not allow uploadingidentical version numbersfor the same package name. This is like the update log of a mobile app:

• Every time a minor bug is fixed or the code is optimized, the version number needs to be updated (e.g., from 1.0.0 → 1.0.1).
• If the version number remains unchanged, the platform will assume that you are repeatedly uploading the same package and thus reject the operation.

The version number follows the ** "major.minor.patch" ** rule (Semantic Versioning), and must be incremented with each upload:

• Revision number (third digit): Fix minor bugs, optimize code details, such as 1.0.0 → 1.0.1.
• Minor version (second digit): New features, compatibility with new hardware, such as 1.0.1 → 1.1.0.
• Major version (first digit): Major overhaul, incompatible with old code, e.g., 1.1.0 → 2.0.0.

If your package name is too broad (such as sensor_driver), it is very likely to have the same name as packages from other developers, leading to confusion during user installation. It is recommended to follow the following rules:

• Package names should be specific: include the hardware model or function, such as bmp280_driver (clearly indicating the BMP280 sensor driver), rather than sensor_driver.
• Format should be standardized: all lowercase, use underscore _ to separate words, and avoid spaces and special characters.
• Pre-search verification: Enter the name of the package you want to use in the search box on the uPyPi homepage, and use it only after confirming that there are no duplicate names.

Steps to resolve the "Version already exists" prompt:

1. Open the package.json file in the driver package, and modify the version field to the new version number (e.g., 1.0.1).
2. Save the file to ensure that the file name and content remain unchanged.
3. Return to the uPyPi upload page, reselect the driver package folder, and click "Upload Package".
4. If the prompt shows "Upload successful", the version update is completed; if an error is still prompted, check whether the package name is a duplicate or whether the version number has indeed been incremented.

5. Related Operation Videos

https://www.youtube.com/watch?v=pXz0Z8Ljfqg

https://www.bilibili.com/video/BV1PVwuzpEyg/?spm_id_from=333.1387.homepage.video_card.click&vd_source=696723cd18d516916a1d480d0a2fce46

[leezisheng]

Hi everyone in the community! 👋
Thank you so much for your continued attention and support for the uPyPI project! Today, I’m excited to share a key update on our ecosystem collaboration:
We have officially partnered with CoCube Robotics (Shanghai Bingqiong Education Technology Co., Ltd.) as a uPyPI Ecosystem Partner. The CoCube Robotics team will fully adopt MicroPython programming and integrate the uPyPI ecosystem infrastructure into their desktop modular robot products and educational scenarios:
Their robot hardware will directly use our chip-level universal drivers, enabling developers to install, update, and manage dependencies for CoCube-related drivers with one click via uPyPI;
We will also provide them with open-source, commercially-free circuit verification board designs to support MicroPython teaching and project development with CoCube robots.