Contents
- 1. Project Background
- 2. What benefits can uPyPi bring?
- 3. Quickly Install the Driver Package
- 3.1 Preparatory Work for Beginners with No Prior Knowledge
- 3.2 Development Board Basic Settings (Flashing MicroPython Firmware)
- 3.3 Open the uPyPi platform to search for packages and copy commands
- 3.4 Download and Install the Driver Package
- 3.5 Use the installed driver package
- 4. Upload Driver Packages (Advanced: For Users Who Want to Share Drivers)
- 4.1 Prepare a compliant driver package file
- 4.2 Upload the driver package to uPyPi
- 4.3 Frequently Asked Questions - Avoiding Version Conflicts and Package Name Duplication
- 5. Related Operation Videos
- Version History
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
| Hardware Name | Usage | Remarks |
|---|---|---|
| Any single-chip microcomputer that supports mpy firmware, whether it supports networking or not, can be used Here, we use Raspberry Pi Pico2 or Pico2W | Core hardware for running MicroPython code | Pico2 has no WiFi functionality (requires local installation); Pico2W has WiFi functionality (can be installed remotely) |
| USB-C data cable | Connect the development board to the computer for code transfer / power supply | Needs to support data transfer (charging cable unavailable) |
| BMP280 Barometric Pressure and Temperature Sensor Module (optional) or other common electronic modules | Test the hardware of the driver package | Used to verify whether the installed bmp280_driver is available |
| DuPont wires (a number of) | Connect the development board to the sensor | Public-to-public / public-to-female DuPont wires need to be prepared, selected according to wiring requirements |
3.1.2 Software Preparation
- 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).
- 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 mpremoteThe 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.
- 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.
- The computer will recognize a USB drive named "RPI-RP2".
- 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/
- Copy and paste the downloaded
.uf2firmware file to the "RPI-RP2" USB drive. - 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.0Wait 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
4.2.1 Local Upload

Ensure that your project's root directory contains the following files (without nested folders, directly placed in the root directory):
code/: Driver code folderLICENSE: License Filepackage.json: Package configuration file (must containnameandversionfields)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 containscode/,package.json, etc.).

Next, package the library files into a Compressed Packet:
- Select all files under the root directory of the selected project (
code/,LICENSE,package.json,README.md). - Right-click → Select "7-Zip" → "Add to Compressed Packet" (or directly select "Add to [Package Name].zip").
- 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
- Compression Format Selection
- 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 successfully uploading, your driver package will be searchable on uPyPi, and other users can install it directly.
4.2.2 Github URL Upload
Submitting the driver package directly via the GitHub repository address is a convenient upload method suitable for open-source projects, and the operation steps are as follows:

Ensure that your driver package code has been hosted on a GitHub repository and meets the following specifications:
- The target directory (repository root directory or subdirectory) must contain
package.jsonfile, and this file must definename(package name) andversion(version number) fields; - The total file size of the driver package does not exceed 10 MiB;
- The target directory does not contain symbolic links (soft links / hard links).

Go to your GitHub repository page, click the green "Code" button, and copy theHTTPS formatrepository URL (e.g.,https://github.com/FreakStudioCN/uPyPI_Test_Package.git) from the pop-up options.

Under the "Upload Driver Package" module on the uPyPi platform, enter the "Upload via GitHub URL" interface, open the "Submit Package from Git Repository" form, and fill in the following information in sequence:
- Git Repository URL: Paste the HTTPS address of the GitHub repository you just copied;
- Branch: Fill in the name of the branch from which you want to pull the code, with the default being
main(if the default branch of your repository ismaster, you need to change it to the corresponding branch name); - Target folder list : Fill in the directory path where the driver package is located (multiple paths separated by English commas), leaving it blank means pulling the entire repository; in the example, fill in
src, lib, indicating that only upload files undersrcandlibdirectories.

Carefully read the "Submission Requirements" below the form, and after confirming that your repository fully complies with the specifications, click the "Submit Package" button.

The platform will automatically pull the code from the specified directory of the GitHub repository, complete the parsing and publishing of the driver package:
- If the submission is successful, the page will display a prompt saying "Upload Successful";
- The newly uploaded driver package can be viewed in the list of "My Panel → Packages I Uploaded", and information such as package name and version number can be confirmed to be correct;
- After the upload is completed, other uPyPi users can directly install and use your driver package by searching for the package name.
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 thansensor_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:
- Open the
package.jsonfile in the driver package, and modify theversionfield to the new version number (e.g.,1.0.1). - Save the file to ensure that the file name and content remain unchanged.
- Return to the uPyPi upload page, reselect the driver package folder, and click "Upload Package".
- 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
Version History
Version Number | Revision Time | Modifier | Modified content |
v1.0 | 2026-02-25 | Lee Eryong | Initial version. |
v1.1 | 2026-03-02 | Lee Eryong | Add English Version Document:Instructions for Downloading and Uploading Driver Packages on the uPyPi Platform |
v1.2 | 2026-03-16 | Lee Eryong | Updated some content, package upload method, and operation video. |
v1.2.1 | 2026-03-16 | Lee Eryong | Updated some content. |
v1.3 | 2026-03-23 | Lee Eryong | Added 4.2.2 Github URL Upload. |