Every Flutter developer knows the feeling. You start a fresh project, open pubspec.yaml, and immediately add the usual suspects: a state management library, a routing package, a screen scaler, a localization helper, a storage solution, and a shimmer package.
Before you’ve written a single line of business logic, you’re already managing 6 to 8 external dependencies.
Then comes the next Flutter SDK upgrade:
• Three packages have conflicting dependency constraints.
• One package is unmaintained.
• Another throws "Looking up a deactivated widget's ancestor" in production because of asynchronous BuildContext lookups.
• And memory leaks silently creep in because controllers aren't bound to route lifecycles.
After building over 50 mobile projects and open-source packages, I asked myself a radical question:
What if we could build scalable, production-grade Flutter apps with strictly ZERO external dependencies?
Today, I’m open-sourcing AppForge (v0.0.1), an all-in-one Flutter micro-framework built using only the Dart standard library and Flutter SDK, achieving a perfect 160/160 quality score on Dart’s official Pana analyzer.
Here is why and how it was engineered.
1. The Core Philosophy: Strictly 0 Dependencies
AppForge has zero third-party packages in its pubspec.yaml.
# appforge pubspec.yaml
dependencies:
flutter:
sdk: flutter
# Absolutely nothing else!
By relying exclusively on dart:core, dart:async, dart:io, dart:convert, and the Flutter SDK:
- Zero version locks: You will never face dependency conflicts when upgrading Flutter.
- Instant build times: No massive transitive dependency trees to resolve or compile.
- Hardware-accelerated performance: Using native engine primitives rather than bloated abstractions.
- Maximized security: Zero supply-chain attack vectors.
2. Micro-Reactive State Management (Rx & Watch)
Most state management solutions either over-engineer with excessive boilerplate or re-render large widget trees unnecessarily.
AppForge introduces surgical, micro-reactive primitives:
// 1. Declare a reactive variable
final count = 0.obs;
// 2. Surgical rebuild - ONLY this Text widget updates
Watch((context) => Text('Count: ${count.value}'))
// 3. Mutate anywhere
count.value++;
Under the hood, Rx uses Flutter’s native ChangeNotifier and optimized notification dispatching, ensuring 120fps fluid frame rates with near-zero memory footprint.
3. Context-Free Navigation & Overlays
Passing BuildContext across async callbacks (after network requests or long-running tasks) is one of the most common sources of Flutter crashes.
AppForge provides a completely context-free navigation and overlay engine:
// Context-free routing
App.to(const DetailsScreen());
App.back();
// Context-free dialogs, snackbars, and loaders
App.snackbar('Operation completed successfully!');
App.dialog(const ConfirmationDialog());
App.showLoading();
App.hideLoading();
4. Route-Bound Auto-Disposal (No Memory Leaks)
Leaking memory when users navigate away from screens is a silent killer in mobile apps. In AppForge, controllers are automatically bound to the route stack and evicted from memory when the route is removed:
class UserController extends AppController {
@override
void onInit() {
print('Initialized!');
}
@override
void onDispose() {
print('Auto-disposed! Zero memory leaks.');
}
}
// In your screen:
final userCtrl = App.put(UserController(), autoDispose: true);
5. Deep Native Arabic & BiDi Formatting (Unicode UAX 9)
Supporting RTL (Right-to-Left) languages in mobile apps is notorious for visual bugs:
• Phone numbers flip their + signs (+974 5500 1234 becomes 5500 1234 +).
• Mixed English and Arabic text causes punctuation marks to jump to the wrong side.
• Arabic requires all 6 grammatical plural forms (zero, one, two, few, many, other), which standard intl often handles awkwardly.
AppForge embeds a native orthography and BiDi sanitizer engine that complies with Unicode Standard Annex #9:
• Isolates phone numbers with LRM/RLM directional marks.
• Preserves punctuation at sentence ends regardless of mixed scripts.
• Supports all 6 Arabic plural forms out-of-the-box.
• Enables in-memory language switching in 0ms with zero app restart.
6. Smart Skeletonizer & POSIX Atomic Storage
Instead of bringing in extra heavy packages for shimmer effects and key-value storage:
Smart Skeletonizer (AppSkeletonizer)
Wrap any widget, and AppForge generates an intelligent wireframe shimmer that matches your layout automatically:
AppSkeletonizer(
enabled: isLoading,
child: const UserProfileCard(),
)
Atomic Key-Value Persistence (AppStorage)
A pure Dart POSIX-compliant key-value engine with crash safety, atomic writes, and zero external binary dependencies:
await AppStorage.write('token', 'xyz_secure_token');
final token = AppStorage.read<String>('token');
7. How We Reached 160/160 on Pana
Pana is the official package scoring tool developed by the Dart team behind pub.dev. Achieving the full score of 160/160 points requires passing strict criteria:
• Conventions (30/30): Full markdown compliance, proper directory structures, and verified semantic versioning.
• Documentation (20/20): 100% public API doc coverage with zero warnings or broken links.
• Platform Support (20/20): Verified support across all Flutter platforms.
• Static Analysis (50/50): 0 linter errors, 0 warnings, and 0 hints across strict analysis configurations.
• Dependencies (40/40): Clean dependency graph that respects the latest stable Flutter & Dart SDKs.
Because AppForge has 0 external packages, it completely bypasses the dependency vulnerabilities and bloat that prevent most packages from keeping a flawless score.
Try AppForge Today
AppForge is completely free, open-source, and live on pub.dev.
Add it to your Flutter project:
flutter pub add appforge
• 📦 pub.dev: https://pub.dev/packages/appforge
• ⭐ GitHub Repository: https://github.com/Dhia-Bechattaoui/appforge
If you find this approach valuable, give the repo a star ⭐ on GitHub, test it out, and let me know your thoughts in the comments!
Top comments (0)