You launch a mobile game—and on the second screen it freezes for 2 seconds. GPU profiling shows spikes, and the Flame game loop stutters. This is a typical problem we solve every day. Our team has been developing games on Flame for over 5 years, shipping 15+ projects to App Store and Google Play. We offer end-to-end development: from prototype to ASO optimization. Save up to 30% of budget with a sound architecture. Contact us to discuss your idea.
Flame is a game engine built on top of Flutter. It's not a separate framework but a package that adds a game loop, component system, physics, and input handling directly into your Flutter project. That means: one codebase for the game and its surrounding UI (menus, settings, shop), native performance on iOS, Android, Web, and Desktop.
Why choose Flame for 2D games?
Flame uses a Component/Entity system. FlameGame is the root component with the game loop. Component is the base class for everything: sprites, text, collisions, UI elements.
class SpaceGame extends FlameGame { @override Future<void> onLoad() async { add(Player()); add(StarBackground()); add(EnemySpawner()); } } The HasCollisionDetection mixin adds collisions to the game. ShapeHitbox (Rectangle, Circle, Polygon) provides hitboxes for components. Callbacks: onCollisionStart, onCollision, onCollisionEnd.
Physics is implemented via Forge2D (Box2D port for Dart)—a separate package flame_forge2d. For simple games, Flame's built-in collision system suffices without Box2D.
What problems does Flame architecture solve?
The first problem: coupling game logic with UI. Flame solves it via FlameGame.overlays: you can embed Flutter widgets (pause buttons, score, modals) directly on the canvas without a separate layer. The second: performance with many objects. Flame uses Flutter's Canvas API, allowing batch rendering via drawAtlas and SpriteBatch.
How to optimize Flame performance?
Flame renders through Flutter's Canvas API—direct calls to canvas.drawImageRect. For many identical sprites (100+ particles, bullets), use SpriteParticle from flame_particles or a custom CustomPainter with drawAtlas—this batches drawing into one draw call, as noted in official Flutter documentation.
Sprite Sheet. SpriteAnimation from an atlas: SpriteSheet.fromColumnsAndRows. Loading individual PNGs per frame is an anti-pattern. gameRef.images.load() caches the image; subsequent calls return the cache.
Performance secrets
- Use
SpriteBatchfor static sprites (background, tiles). - Limit
updatecalls: togglegame.pausedwhen the game is hidden. - For particles, use
ParticleEffectComponentinstead of individual sprites.
Comparison of Flame with other 2D engines
| Criteria | Flame | Unity 2D | Godot 2D |
|---|---|---|---|
| Codebase | One (Flutter) | Two (C# + platform) | One (GDScript) |
| Prototyping time | 1–2 weeks | 2–4 weeks | 2–3 weeks |
| UI integration | Natural (Flutter widgets) | Via Canvas (separate) | Via Control nodes |
| Store support | App Store / Google Play (via Flutter) | Own builds | Separate plugins |
| Community | Small but growing | Huge | Medium |
Flame loses to Unity in 3D but wins in development speed for 2D games integrated with the Flutter ecosystem. For typical projects, Flame is 2x faster, as confirmed by our practice.
Timelines and cost
| Game type | Prototype | Full version |
|---|---|---|
| Hyper-casual | 3–6 weeks | 2–3 months |
| Casual with meta | 1–2 months | 3–5 months |
| RPG/strategy | 2–3 months | 5–8 months |
Cost is determined after analyzing your concept. Contact us for a consultation.
What's included in our work
- Architecture documentation (component diagrams, game loop description).
- Source code on GitHub with CI/CD (GitHub Actions for iOS and Android builds).
- Firebase setup for analytics, push notifications (APNs/FCM), crash reports.
- Integration of StoreKit 2 / Billing 6 for purchases, App Tracking Transparency.
- Testing: unit tests, widget tests, integration tests with flame_test.
- Publishing to App Store and Google Play with ASO optimization (keywords, screenshots).
- Training for your team (2 sessions, 2 hours each) and 3 months of post-release support.
Development process
- Analysis—we discuss the concept, gameplay, monetization. Estimate timelines.
- Design—create architecture, prototype the core loop in 1–2 weeks.
- Implementation—write game mechanics, integrations, UI.
- Testing—QA on 5+ real devices, Crashlytics, profiling.
- Deployment—publish to stores, set up CI/CD, hand over source code.
Order development with a guarantee on architecture and optimization. Get a consultation—write to us, we will evaluate your project.