🚀 Bomiot

One App You Can Do Everything

Enterprise System Integration Platform · Full-Stack Node-Based Development Platform — Connect Systems · Node Networking · Portable Distribution · Open-Source Sharing

🏢 Connect ERP / WMS / CRM / MES / OA, End Enterprise Data Silos

English | 中文

📑 Table of Contents

About Bomiot
Video Introduction
Core Features Overview
Use Case Examples
Quick Start
CLI Reference
Configuration Reference
Scheduled Tasks
File Monitoring & Upload
Real-time System Monitoring
Real-time WebSocket Communication
Deployment & Distribution
Security Notice
Contributing
License

🌟 About Bomiot

Bomiot is an enterprise system integration platform and also a full-stack node-based development platform, with its core ASGI gateway rewritten in Rust, designed specifically to connect all systems within an enterprise.

Whether it's ERP, WMS, CRM, MES or OA, Bomiot's node-based architecture helps you achieve system connectivity, data flow and unified management — ending enterprise data silos. Every user / every device can be an independent node; nodes collaborate directly over the local area network. Applications can be compiled into portable distributions in one click — double-click to run, no environment dependencies. Bomiot also ships with a built-in free application marketplace with pre-installed industry templates such as ERP / WMS, where developers can freely publish and share applications.

Enterprise Pain Points	Bomiot Solutions
🏢 Fragmented Systems, Data Silos	✅ Enterprise System Integration — unified access for ERP/WMS/CRM/MES/OA, data flows on demand
🐢 Bulky Deployment, Environment Coupling	✅ Portable Distribution, compiled to binary, drastically reduced runtime dependencies
🔗 Multi-Site / Multi-Facility Collaboration	✅ Node-based Networking — nodes connect directly via LAN, decentralized, no central server required
🧩 Separated Frontend & Backend, Complex Integration	✅ Full-Stack Unification — Python backends (Django/FastAPI/Flask) + mainstream frontends, flexible combinations
📡 No Real-Time Channels, Inefficient Polling	✅ Built-in WebSocket, native ASGI implementation, real-time bidirectional communication
🛡️ Performance Bottlenecks, Code Leakage	✅ Rust-rewritten ASGI Gateway, compiled to native binary, more stable performance and effective code protection
💰 Closed Ecosystem, Hard to Reuse	✅ Own Free Application Marketplace with pre-built industry templates; developers freely publish and share applications

📹 Video Introduction

Watch the video introduction of Bomiot to quickly understand the core features and usage of the platform.

▶ Click to Watch Video Introduction (YouTube)

✨ Core Features Overview

1. Enterprise System Integration (Unified Multi-System Access · End Data Silos)

Purpose-built for connecting internal enterprise systems. ERP, WMS, CRM, MES, OA — inconsistent interfaces don't matter. Bomiot connects everything for you.

🏢 Multi-System Connectivity: Standard APIs, direct database access, or UI-level automation — all can be unified into Bomiot nodes.
🔄 Real-Time Data Flow: Real-time fetch and push between nodes; business states sync across systems at millisecond level.
🧩 Unified Permission System: Single account for all subsystems; centralized role & API permission control.
📊 Unified Monitoring Dashboard: All node statuses, system health and core business metrics on one screen.
🌐 Node-based Networking: Multi-site, multi-facility and multi-branch nodes interconnect over LAN — decentralized, no central server required.

2. Cross-Platform Node-Based Architecture (Zero-Dependency)

Develop once, distribute cross-platform. The compiled and encrypted portable program turns every Windows / macOS / Linux device into an independent server node, supporting industrial PCs and edge gateways for IoT devices.

🌍 Full Platform Support: Native support for Windows, macOS and Linux, one codebase runs everywhere.
📦 Portable Distribution: Packages code, runtime and resources into an encrypted portable program through compilation, no installation required, ready to use after extraction.
⚡ Instant Run: No need to install Python, no need to configure environment, double-click to run.
🔒 Local Data: Data is stored on each node, complying with data sovereignty requirements.
🤖 Edge Device Support: Compatible with industrial PCs, Raspberry Pi, edge gateways and other IoT devices to build edge computing nodes.

3. Multi-Language Full-Stack Framework Freedom

No restrictions on tech stack, use the tools you are most familiar with. Bomiot supports a flexible combination of Python backend + JavaScript frontend.

Backend Support (Python):
- 🟢 Django (Enterprise-grade preferred)
- 🚀 FastAPI (High concurrency performance)
- ⚪ Flask (Lightweight and flexible)
Frontend Support (JavaScript/TypeScript):
- 💚 Quasar / Vue 3 (Primary support, fully integrated)
- 🔄 Abstraction layer reserved, extendable to React and Angular.

4. Rust Rewritten ASGI Gateway

Bomiot uses Rust to rewrite the core ASGI gateway, compiles it into native binaries, bringing more stable performance and code protection.

🦀 Rust ASGI Gateway: The core gateway is written in Rust, compiled to native binaries, with more stable performance.
🚀 Stable Performance: The compiled binaries have lower latency and more stable operation under high-concurrency requests.
🔐 Code Protection: Python code is converted to native binaries along with compilation, effectively improving code protection.

5. Built-In Free Application Marketplace · One-Click Industry Template Installation

Bomiot has a free and open application marketplace with pre-installed industry templates such as ERP / WMS. Developers can also freely publish and share applications.

🏪 Free Application Marketplace: Built-in official marketplace, developers can freely publish applications, users can download with one click, completely free.
🎯 Industry Templates: Pre-built templates including GreaterWMS (WMS), install in one click and ready to use.
🔓 Open Sharing: All marketplace content is open for download to everyone, promoting the rapid dissemination and reuse of technology.
🔐 Secure Distribution: Applications can be compiled and encrypted before publishing, protecting developers' code choices.

6. Built-In Scheduled Task Scheduling

A built-in database-driven scheduled task system supports multiple trigger methods.

⏰ Three Triggers: Supports cron (scheduled), interval (interval), date (date) three trigger methods.
💾 Database Persistence: Tasks are stored in the database, automatically restored after service restart.
🔄 Auto Sync: SchedulerManager automatically synchronizes task status every 60 seconds, adding, deleting and modifying take effect immediately.
📝 Task Template: Define task functions in task.py, which can be called and executed by the scheduler.

7. File Monitoring & Upload

Real-time file monitoring system automatically manages user-uploaded files.

👀 Real-Time Monitoring: Automatically monitors the media directory, captures file creation, modification, deletion and movement operations.
📋 Auto Registration: File changes are automatically written to the database, recording file name, type, size and owner.
📡 Event Notification: File changes are broadcast in real-time through the signal mechanism, convenient for frontend or third-party subscriptions.
⚙️ Flexible Configuration: Set file size limits and allowed file types in setup.ini.

8. Real-Time WebSocket Communication

Bomiot's Rust ASGI gateway natively supports WebSocket. You can directly write WebSocket routes in the application's main.py. For details, see the WebSocket Section.

💬 Minimal Development: Directly use the standard WebSocket syntax of FastAPI/Flask, zero learning cost.
⚡ Gateway Forwarding: The Rust gateway automatically identifies WebSocket requests and efficiently forwards them to the corresponding application.
🔌 Full Framework Support: Can be used in main.py of Django, FastAPI or Flask applications.

9. Real-Time System Monitoring

Backend system monitoring, real-time collection of server running status.

💻 CPU Monitoring: Collects CPU usage, physical cores, logical cores, frequency information.
🧠 Memory Monitoring: Collects total, used, available and usage of physical memory and swap partitions.
💽 Disk Monitoring: Collects capacity, used, available and usage of each partition.
🌐 Network Monitoring: Collects bytes sent and received over the network.
📊 Process Monitoring: Collects PID, name, CPU usage and memory usage of all running processes.
🗄️ Auto Cleanup: Historical data is automatically cleaned up (upper limit of 10080 entries) to prevent database bloating.

10. Built-In API Rate Limiting Protection

Provides out-of-the-box API security protection for your applications to ensure system stability.

🛡️ Intelligent Rate Limiting: Fine-grained rate limiting based on IP address and HTTP request method (GET/POST, etc.).
🛡️ Anti-Scraping Protection: Effectively prevents malicious crawlers, interface scraping and denial-of-service (DoS) attacks.
⚙️ Flexible Configuration: Customize the rate limiting time window and request frequency in the [throttle] section of setup.ini.

💡 Use Case Examples

Bomiot's platform capabilities make it suitable for a variety of real-world business scenarios. Here are some typical examples:

🏭 Automated Enterprise System Integration

Various enterprise internal systems (WMS, ERP, MES, OA, CRM, etc.) are often difficult to integrate due to inconsistent interfaces. With Bomiot + browser automation tools (such as Playwright), you can achieve UI-level automation without modifying any system code:

Real-time fetch data from one system and automatically fill it into another
Monitor business status changes and synchronize across systems in real time
No need for the target system to provide an API; complete data transfer directly through UI operations
Cooperate with Scheduled Tasks + WebSocket notifications to alert exceptions immediately

🛒 E-Commerce Price & Inventory Monitoring

Build automated e-commerce monitoring applications to help operations teams stay on top of market dynamics:

Periodically scrape competitor prices and promotional information, generating price change reports
Monitor product inventory status and automatically trigger alerts when stock is low
Support simultaneous monitoring across multiple platforms (Taobao, JD, Pinduoduo, etc.)
Data changes are pushed to the frontend dashboard in real time via WebSocket
After development, it can be compiled into a portable version, distributed to multiple operators for independent operation, data does not affect each other

📊 Data Inspection & Automated Reporting

Leverage scheduled tasks + file monitoring capabilities to build automated data processing pipelines:

Periodically collect business data from data sources (databases, files, APIs)
Automatically generate Excel / PDF reports and distribute them to designated personnel
Monitor key business indicators and automatically trigger alert notifications on anomalies
Portable distribution, deployed to various departments for independent operation, data stays local

🔧 General Automation Toolkit

Transform repetitive tasks into automated workflows to boost team efficiency:

Automated form filling and submission (HR systems, finance systems, etc.)
Automated document generation and archiving
System health inspection and automatic restart
One-click compilation to portable runtime files after development, easy distribution across multiple devices and personnel

🤖 Industrial IoT & Edge Computing

Deploy Bomiot nodes to industrial PCs and edge gateways to build decentralized IoT solutions:

Edge Data Collection: Real-time collection of sensor data on on-site equipment in workshops and warehouses
Local Processing & Alerts: Data processed locally at edge nodes, low-latency alert triggering
Multi-Node Collaboration: Multiple edge nodes collaborate over local network without cloud servers
Data Sovereignty: Sensitive production data retained on local nodes, complying with industrial security requirements
Remote Operations: Remote monitoring of edge node running status via WebSocket

🏠 Smart Home & Edge Gateway

Use Bomiot as an edge gateway for homes or offices to centrally manage smart devices:

Unified Device Access: Connect various smart devices (lights, sensors, cameras, etc.) via MQTT protocol
Automation Orchestration: Define automation rules, such as "automatically turn on AC when temperature is too high"
Local Automation: Offline operation, data stays local, protecting privacy
Portable Distribution: Plug-and-play deployment to home servers or mini PCs

🚀 Quick Start (5-Minute Hands-On)

# 1. Install Bomiot
pip install bomiot

# 2. Initialize workspace
bomiot init

# 3. Create project, app and API
bomiot project my-project
bomiot app my-app
bomiot api my-api

# 4. Initialize database and admin
bomiot migrate
bomiot initadmin

# 5. Start service
bomiot run --host 0.0.0.0 --port 8000

Done! Open http://127.0.0.1:8000/ to start your development journey.

🛠️ CLI Reference

Category	Command	Description
Project	`bomiot init`	Initialize workspace
	`bomiot project <name>`	Create new project
	`bomiot app <name>`	Create new app
	`bomiot api <name>`	Create new API
Database	`bomiot makemigrations`	Generate migration files
	`bomiot migrate`	Execute database migration
	`bomiot loaddata <source>`	Load initial data
	`bomiot dumpdata [appname]`	Export data
Service	`bomiot run [options]`	Start development server
	`bomiot deploy`	Deploy project (compile and package)
Admin	`bomiot initadmin`	Create admin account
	`bomiot initpwd`	Reset admin password

🔧 Configuration Reference (`setup.ini`)

[project]
name = greaterwms

[database]
# engine: sqlite | mysql | postgresql | oracle
engine = sqlite
# ... other database connection information ...

[debug]
# Control production/debug mode
debug = True

[file]
# File upload configuration
file_size = 102400000    # Maximum file size (bytes), default 100MB
file_extension = py,png,jpg,jpeg,gif,bmp,webp,txt,md,html,htm,js,css,json,xml,csv,xlsx,xls,ppt,pptx,doc,docx,pdf

[system_control]
# Backend service switches
observer = True        # File monitoring
scheduler = True       # Scheduled task scheduling
server_monitor = True  # System resource monitoring

# ... (other configuration items)

⏰ Scheduled Tasks

Bomiot has a built-in scheduled task system, defines tasks through task.py, and supports three trigger methods.

Define Tasks

Define task functions in task.py of the workspace:

def example_job(**kwargs):
    """Example task function"""
    from datetime import datetime
    print(f"Execution time: {datetime.now()}")
    # Write your business logic here

Trigger Types

Type	Description	Example
`cron`	Trigger regularly according to Cron expression	Execute backup at 02:00 every day
`interval`	Trigger at fixed intervals	Check once every 5 minutes
`date`	Trigger once at the specified time	Execute at 23:59 on 2026-12-31

Enable Scheduling

Ensure scheduler = True in [system_control] of setup.ini. The scheduler will run automatically after the service starts.

📁 File Monitoring & Upload

Bomiot has a built-in file monitoring system that automatically tracks changes in user-uploaded files.

Monitoring Mechanism

Real-Time Monitoring: Monitors the MEDIA_ROOT media directory, recursively listens to all subdirectories.
Event Capture: Automatically captures four operations of file creation, modification, deletion and movement.
User Association: Automatically identifies the file owner according to the directory level and writes it to the Files data table.
Signal Notification: Every file change broadcasts an event through bomiot_signals, and the frontend can subscribe in real-time.

Upload Configuration

Configure upload parameters in the [file] section of setup.ini:

[file]
file_size = 102400000    # Maximum file size (default 100MB)
file_extension = png,jpg,pdf,docx,...  # Allowed file extensions

Enable File Monitoring

Ensure observer = True in [system_control] of setup.ini. File monitoring will be automatically enabled after the service starts.

📊 Real-time System Monitoring

Bomiot has a built-in system monitoring module that collects core operating indicators of the server in the background. The data is stored in the database and broadcast in real-time through signals.

Monitoring Indicators

Indicator	Collection Content	Storage Model
CPU	Usage, physical cores, logical cores, frequency	`CPU`
Memory	Total, used, available, Swap information	`Memory`
Disk	Capacity, used, available, usage of each partition	`Disk`
Network	Bytes sent, bytes received	`Network`
Process	PID, name, CPU usage, memory usage	`Pids`

Collection Frequency

Perform a complete collection every 5 minutes
CPU, memory, network data are automatically cleaned up (upper limit of 10080 entries ≈ 7 days)
Disk and processes are fully refreshed each time

Enable System Monitoring

Ensure server_monitor = True in [system_control] of setup.ini. The monitoring will automatically run in a background thread after the service starts.

📡 Real-time WebSocket Communication

Bomiot's Rust ASGI gateway natively supports WebSocket, no additional configuration required. Just write WebSocket routes directly in the application's main.py.

Development Example

In the FastAPI application's main.py:

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Message text was: {data}")

Core Features

💬 Minimal Development: Directly use the standard WebSocket syntax of FastAPI/Flask, zero learning cost.
⚡ Gateway Forwarding: The Rust gateway automatically identifies WebSocket requests and efficiently forwards them to the corresponding application.
🔄 Bidirectional Communication: Supports server-side active push, enabling real-time notifications, data broadcasting and other scenarios.
🔌 Ready-to-Use: No additional dependencies required, natively supported by the framework.

Typical Use Cases

Real-time Data Dashboard: Monitor metric changes pushed to the frontend in real time
System Alert Notifications: Alert users immediately through WebSocket when exceptions occur
Collaborative Editing: Multiple people collaboratively operating the same data in real time
Chat & Messaging: Instant messages, notification broadcasting

🌐 Deployment & Distribution

Traditional Server Deployment (Free)

You can deploy Bomiot applications to any server like a traditional Django/FastAPI project, completely free, no restrictions.

# Traditional server deployment
bomiot run --host 0.0.0.0 --port 8000

Node-Based Distribution (Sponsor Only)

bomiot deploy  # Cross-platform compilation to portable runtime files

Generates portable runtime files through cross-platform compilation and packaging, copy it to the target machine and double-click to run. This distribution method is Sponsor Only, featuring compiled encryption and instant cross-platform deployment.

💡 Note: Node-based distribution supports both on-premises physical devices and cloud server environments. The portable runtime files generated by bomiot deploy can be deployed directly to physical devices on the enterprise intranet (PCs, industrial PCs, edge gateways, Raspberry Pi, on-premise data-center servers, etc.), as well as to cloud server instances. The device-bound verification mechanism is consistent across all scenarios.

Device-Bound Verification Mechanism:

On first run, the program automatically generates auth_key.py based on the local network card information
Visit the official website with auth_key.py to complete verification and exchange for sponsor.py
All verifications are completed locally, bound to the unique device identifier, only valid for the current device
Each device can only have one sponsor.py; changing hardware or cloud server instance requires re-binding.

Privacy Protection Commitment: All verifications are completed locally, and your node information or business data will not be uploaded to any server. Your code, configuration and operational data are always retained on local nodes.

⚠️ Security Notice

Data Ownership and Privacy

Local Verification: All verification mechanisms run entirely locally, no network connection required, and no user data collected.
Data Sovereignty: All business data, configuration files and operation logs are stored on local nodes, and you have absolute control over your data.
No Third-Party Dependencies: Except for the operating system itself, Bomiot will not force you to install any cloud service or send telemetry data to third parties.

About Code Protection

Compilation converts Python code to native binaries, effectively improving code protection.

It is recommended to place core algorithms and sensitive logic on the server-side node rather than the client-side
For high security requirements, it is recommended to cooperate with code signing and local verification mechanisms

Deployment Recommendations

For production environments, please set debug in [debug] of setup.ini to False
External network deployment must configure HTTPS (--ssl-keyfile + --ssl-certfile)
Regularly back up the database (bomiot dumpdata) and setup.ini configuration

🤝 Contributing

We welcome contributions of any form!

🔗 Official Website: https://www.bomiot.com
🐛 Submit Bug: Create Issue
✨ Feature Suggestion: Submit Feature Request
💻 Code Contribution: Fork the repository -> Create a branch -> Submit a Pull Request
🧩 Share Applications: Develop industry applications based on Bomiot and publish them to the free application marketplace to share with the community

📄 License

This project is licensed under the Apache License 2.0, see LICENSE file for details.

⭐ If Bomiot is helpful to you, please give the project a Star!

Made with ❤️ by Bomiot Team

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

bomiot-1.2.5.tar.gz (8.6 MB view details)

Uploaded Aug 23, 2026 Source

Built Distribution

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

bomiot-1.2.5-py3-none-any.whl (9.0 MB view details)

Uploaded Aug 23, 2026 Python 3

File details

Details for the file bomiot-1.2.5.tar.gz.

File metadata

Download URL: bomiot-1.2.5.tar.gz
Upload date: Aug 23, 2026
Size: 8.6 MB
Tags: Source
Uploaded using Trusted Publishing? No
Uploaded via: poetry/1.8.3 CPython/3.11.9 Windows/10

File hashes

Hashes for bomiot-1.2.5.tar.gz
Algorithm	Hash digest
SHA256	`1962ba46559ce76db8d12e215b2a2e8d547f80952b4285a5fd0af5dc2e05f6d3`
MD5	`e2b0687a664a1b423a362054f7781846`
BLAKE2b-256	`a9d8599cbe59aa1ace22c4c317772b4c2e9a59969f254543ac12d64be839bd9c`

See more details on using hashes here.

File details

Details for the file bomiot-1.2.5-py3-none-any.whl.

File metadata

Download URL: bomiot-1.2.5-py3-none-any.whl
Upload date: Aug 23, 2026
Size: 9.0 MB
Tags: Python 3
Uploaded using Trusted Publishing? No
Uploaded via: poetry/1.8.3 CPython/3.11.9 Windows/10

File hashes

Hashes for bomiot-1.2.5-py3-none-any.whl
Algorithm	Hash digest
SHA256	`d4bc79e2882565ebada381f1804476e2a5d9ba7a6b62bb5cdc06aee6d0c675de`
MD5	`5d106ca42339d5866f8e6332ee7ea1f9`
BLAKE2b-256	`44eb020bd2105cebc3324108db0ee6eb666c0a041ab89691fa342f08faa99544`