Pure Dart Backend.
Django Power. Rust-Grade Concurrency.
Stop writing backend APIs in Node or Go with duplicate data models. Bloom delivers an integrated 15-package backend ecosystem for pure Dart: typed ORM, schema migrations, DRF ViewSets, auto HTML admin, and 78k msgs/s multi-isolate realtime clustering.
BUILT ON THE SHOULDERS OF GIANTS
Google Cloud
Flutter 3.29
Dart 3.7
Firebase
GitHub
iOS / Apple
AndroidGoogle CloudFlutter 3.29Dart 3.7FirebaseGitHubiOS / AppleAndroidOne Language. One Workspace.
Organize Mobile (Flutter), Web (Flutter Web), and Backend (Bloom Server) in a clean, pipeline-first monorepo with 100% shared type safety.
Pure Dart packages/core
Data models, serializers, and query keys live in pure Dart. Zero Flutter engine dependencies allows the backend server to import models directly.
Zero Codegen Drift
Client BloomQuery and server BloomViewSet communicate directly using identical Dart schemas. No OpenAPI or JSON generators needed.
Unified Melos Task Pipelines
Run melos run dev to hot-reload backend servers, mobile emulators, and web clients simultaneously across all CPU cores.
Hardware Performance Breakdown
Pure Ahead-of-Time (AOT) machine compilation and dedicated isolate memory heaps deliver 29x less RAM and zero garbage collection spikes.
1,000 active concurrent WebSocket connections @ 3.70 MB RSS memory (Node.js/Fastify requires 107 MB).
5,000 database rows batched in 400.7ms with zero object allocation overhead and typed query builders.
100 parallel HTTP connections handled with 0 socket drops and sub-30ms latency ceilings.
10,000 operations in 84.0ms with built-in dogpile stampede locks and swappable Redis backends.
Architectural & Benchmark Audit Comparison
Direct comparison across server architectures tested on Apple M-Series Silicon and Linux AMD64 hardware.
| Capability / Metric | Bloom (Dart AOT) | Node.js (NestJS/Fastify) | Go (Gin/Fiber) | Python (Django/FastAPI) |
|---|---|---|---|---|
| Compilation & Runtime | Pure Native AOT | V8 JIT / Bytecode | Native Machine Code | Interpreted CPython |
| 1,000 WebSocket RAM (RSS) | 3.70 MB (Baseline) | 107.4 MB (29x more) | 42.1 MB (11x more) | 182.0 MB (49x more) |
| 5k Batched ORM Inserts | 400.7ms (12.5k ops/s) | 1,620ms (Prisma GC lag) | 610ms (GORM reflection) | 2,450ms (Python loop lag) |
| 100 Concurrency p99 Latency | 29.3ms (9,091 req/s) | 118.0ms (4,210 req/s) | 38.2ms (8,400 req/s) | 240.0ms (1,850 req/s) |
| Flutter Client Sharing | 100% Shared Primitives | Requires Codegen / DTOs | Requires Protobuf / OpenAPI | Requires OpenAPI Codegen |
| Multi-Core Scaling | Native Isolate Mesh | PM2 Process Cluster | Goroutines & Channels | Gunicorn Multi-Worker |
| Auto HTML Admin Panel | Built-in (bloom_admin) | External Third-Party | None (Manual UI) | Built-in (Django Admin) |
| Schema Migrations | Deterministic Linear Diff | Prisma / TypeORM CLI | golang-migrate | Django makemigrations |
The 15-Package Server Ecosystem
Modeled on Django's battle-tested modularity and designed to work seamlessly together or as standalone Dart packages.
Core foundational primitives, request/response models, and unified client-server pipeline.
Declarative typed ORM with compile-time query safety for SQLite and PostgreSQL.
Automatic schema diffing and linear migration execution engine without manual SQL.
DRF-style REST layer with ViewSets, serializers, pagination, filters, and throttle rules.
Zero-config server-rendered HTML administration interface for your database models.
High-throughput WebSocket pub/sub with multi-isolate clustering (78,125 msgs/s).
Memory LRU, Database, and Redis backends with cache stampede prevention locks.
Session and JWT authentication server with bcrypt password hashing and RBAC.
Asynchronous background worker queue with retries, cron, and concurrency controls.
Transactional email engine with SMTP, SendGrid, and Postmark delivery backends.
Swappable file storage abstraction (Local disk, AWS S3, Cloudflare R2, MinIO).
Security headers, CSRF token validation, CORS, and rate-limiting middleware.
Frequently Asked Questions About Pure Dart Server
Key architectural insights into the pure Dart backend ecosystem, benchmarks, and Django patterns.
Why write backend servers in Pure Dart instead of Node.js, Go, or Python?
Pure Dart compiles Ahead-of-Time (AOT) to native machine code with separate isolate memory heaps, completely eliminating Node.js single-thread event loop blocking and JavaScript's massive memory overhead. Bloom Server processes 78,125 WebSocket messages/sec at just 3.70 MB RAM (compared to 107 MB for Fastify) while allowing you to share exact data models, validation schemas, and types directly with your Flutter client without code generators.
How is Bloom Server modeled on Django and djangors-*?
Bloom Server adopts Django's battle-tested architectural modularity: domain apps in `lib/apps/<name>/` containing `models.dart`, `serializers.dart`, `views.dart`, and `admin.dart`. It includes declarative `@Model()` declarations, automated deterministic SQL migrations (`bloom_migrate`), Django REST Framework style `BloomViewSet` routing with composable permissions, and an instant server-rendered HTML admin panel (`bloom_admin`).
What databases does Bloom Server's ORM (bloom_db) support?
bloom_db provides native compile-time typed query builders and drivers for both SQLite (embedded native/WAL mode) and PostgreSQL. It delivers zero-overhead query execution, transactions, connection pooling, and linear schema diffing through bloom_migrate.
How does multi-isolate clustering work in bloom_realtime?
BloomRealtimeCluster binds all available CPU cores to the same network port using `HttpServer.bind(shared: true)` combined with high-speed inter-isolate SendPort meshes. Incoming WebSocket traffic and HTTP requests are automatically load-balanced across isolate cores by the OS kernel with zero thread contention.
Can I use Bloom Server standalone without Flutter?
Yes! While Bloom Server integrates seamlessly with Flutter clients via shared BloomQuery/BloomMutation primitives, all 15 server packages (bloom_db, bloom_rest, bloom_admin, bloom_realtime, bloom_jobs, bloom_mail, bloom_cache, etc.) are pure Dart packages that can be used to build any REST, GraphQL, WebSocket, or microservice backend.
How does background job processing and caching work in Bloom Server?
bloom_jobs delivers asynchronous background worker queues with configurable concurrency, exponential backoff retries, and cron scheduling. bloom_cache provides a unified caching API with In-Memory LRU, Database, and Redis backends, featuring built-in stampede protection (`getOrSet` dogpile locks) and HTTP response caching middleware.
Build Full-Stack Apps with Pure Dart
Scaffold your first server application in seconds with full database migrations, authentication, and REST ViewSets out of the box.