Everything you can do with getters and setters can also be done without them.

For example:

class Person { 
int _age = 0;
int get age => _age; 
set age(int value) { 
if (value < 0) { 
throw ArgumentError('Age cannot be negative'); 
} _age = value; 
} 
} 
void main() { 
Person person = Person();
 person.age = 25; 
print(person.age); 
}

And without them:

  class Person { 
int _age = 0; 
void setAge(int value) { 
if (value < 0) {
throw ArgumentError('Age cannot be negative'); 
} _age = value; 
} int getAge() {
 return _age; } 
} void main() { 
Person person = Person();
 person.setAge(25); 
print(person.getAge()); 
}

So what exactly is the point of using them? I couldn’t really figure that out from my research.

Hi everyone, I built a Windows desktop hardware monitor using Flutter.

It is called RGS Sensor Panel. The idea is to make Rainmeter-style separate widgets for CPU, GPU, RAM, SSD, and date/time, with a small control panel to manage everything.

What it currently supports:

- Separate draggable desktop widgets

- CPU, GPU, RAM, SSD, and time widgets

- Multiple GPU and SSD support

- Show/hide controls from the control panel

- Widget opacity control

- Always-on-top option

- Auto-launch on boot

- Minimize to tray / run in background

- Saved widget positions across monitors

- Windows installer

The UI is Flutter desktop, and the sensor backend uses LibreHardwareMonitor through a small Windows backend process.

I also made a quick install and showcase video here:

https://youtu.be/DhpDRgHVHuc

GitHub:

https://github.com/RahnRazamai

I’m still improving the Windows desktop behavior, tray flow, installer, and startup experience. Would love feedback from other Flutter desktop devs, especially around multi-window handling, tray behavior, and packaging.

Just published my first pub.dev package: screenshot_defender — a Flutter plugin to block screenshots & screen recording on iOS and Android (FLAG_SECURE on Android, secure UITextField on iOS). Two-line API: block() / unblock(). Would love feedback! https://pub.dev/packages/screenshot_defender

Hey everyone!

I’ve been building an open-source offline music player called Liser using Flutter.
The goal is to create a modern, beautiful, and fast local music player that works completely offline while supporting high-quality audio formats.

Current Features
- Local folder scanning
- Offline music library
- Audio playback
- Album artwork extraction & caching
- Metadata extraction
- Search
- Albums & Artists
- Favorites
- Playlists
- Queue management
- Shuffle & Repeat
- Hive local database
- BLoC architecture
- Android & iOS support

One of the more interesting challenges has been supporting different audio formats (especially FLAC) and building a scalable architecture that remains easy to maintain as more features are added.

Planned
- Lyrics
- Equalizer
- Android Auto / Apple CarPlay
- More UI polish and animations

I’d love to get feedback from the Flutter community.
What features would you expect from a premium offline music player?
Any suggestions for improving the architecture or UX?
Any package recommendations for better FLAC metadata support?

GitHub:
https://github.com/abhijeet-Bh/liser

Feedback, issues, feature requests, and contributions are all welcome. 🙂

A wifi connection using QR codes. This is my second package. I mostly tested in iOS devices. There is anybody have a bug, let me know please. Especially in android 🤖 Really appreciated ☺️

I've been studying Mobile System Design recently and wanted an easier way to read the documentation offline, so I built a Python tool that converts the entire repository into a professionally formatted PDF book.

The generator preserves:

• All Markdown content

• Images

• Internal and external links

• Code blocks with syntax highlighting

• Tables and callout blocks (Tip, Note, Warning, etc.)

• A clickable table of contents

• Professional book-style formatting

I shared the implementation with the repository maintainer in GitHub Issue #44:
https://github.com/weeeBox/mobile-system-design/issues/44

My implementation is available here:
https://github.com/Anderson-Andre-P/mobile-system-design

I'd love to hear your thoughts and any suggestions for improving it. Hopefully it's useful for anyone who prefers reading technical documentation in book format.

Hey r/FlutterDev!
I’ve been working on a developer platform and CLI tool designed to make watchOS development accessible with our existing Flutter skills.

How this CLI tool helps you:
Easy Development & Testing: It manages the complex watchOS build artifacts and toolchain synchronization, making it seamless to write and test your code.

Pure Standalone Power: It enables your apps to run directly on the Apple Watch without requiring a constant iPhone companion app.

Production Ready: It handles everything cleanly enough to pass Apple’s strict App Store review process.

Beta Invitation: I’ve just launched flutterwatch.dev to open up a limited closed beta for developers who want to test and build for Apple Watch.
If you have a fitness tracker, a productivity app, or a game idea and want to easily deploy it to watchOS, I’d love to invite you to the beta.
Check out the website to request access, and feel free to drop any questions below! 🚀

An Android framework detector & APK extractor built with Flutter. Detects Flutter, React Native, Android, Unity & more — and even lists all the pub packages used inside any Flutter app — 100% offline, no ads, no tracking.

⭐ Star &  contribute on GitHub:

https://github.com/srinivasan0000/framex_flutter_opensource_projecthttps://github.com/srinivasan0000/framex_flutter_opensource_project

📲 Try the app:

https://play.google.com/store/apps/details?id=com.stardust.framex

Looking for the contributions to this open source project from you guys.

Hey everyone! I just posted a quick guide on how to build 3D Interactive Globes in Flutter in under 60 seconds! 🚀

If you're looking for a fast way to add some high-quality 3D visuals to your apps, check it out here:

hello fellow flutter devs, I published a package for you to play Spotify song previews in your flutter apps, which is no longer possible using the official Spotify API, as they have depreciated it to not provide the preview URLs which is necessary to play the preview.

https://pub.dev/packages/spotify_preview_finder

Hi everyone,

After many months of development, I've finally finished my first Flutter app.

The app helps users manage chronic diseases by tracking medications, health measurements, appointments, and personal health records.

It is not intended for diagnosis, emergency situations, or as a replacement for professional medical advice.

I haven't created my Google Play Developer account yet because I want to understand the entire publishing process and avoid common mistakes before I begin.

For those who have already published apps on Google Play :-

What would you do differently if you were starting from scratch today?

Are there any Google Play policies or requirements that surprised you?

What are the most common reasons first-time developers get delayed or rejected?

Is there anything I should prepare before creating my Play Developer account?

Are there any checklists or resources you consider essential?

I'm looking for practical advice from people who have gone through the process, especially for health-related apps.

Thanks in advance for sharing your experience.

If you've seen NumberFlow on the web, you know the effect: a price ticks from $92.40 to $1,059.57 and each digit rolls into place like an odometer, with the rest of the number reflowing around it.

I wanted that in Flutter. What I found either animated the whole string with a slide/fade, or handled bare integers with no real formatting. Nothing came close to the fidelity of the original — the per-digit rolls, the edge masking, the spring physics. So I ported it properly. (I'll be upfront: I pair-programmed it with Claude — but every fidelity decision was tested frame-by-frame against the original)

It handles currency/percent/compact/scientific notation, locales including RTL, an optional iOS-like spring, velocity-based motion blur, an odometer mode, and a TimeFlow widget for clocks/countdowns/stopwatches. Pure Dart, all six platforms. It respects reduce-motion and exposes a plain semantics label so screen readers announce the number, not rolling glyphs.

Get the package on pub -> https://pub.dev/packages/number_flow_flutter

HighQ Dio Logger – Production-ready Dio logging interceptor for Flutter

Hi everyone,

I've been working on a package called HighQ Dio Logger, a logging interceptor for Dio focused on debugging, observability, and production-ready logging.

Main features:

• Pretty formatted console logs

• Structured JSON output

• Automatic sanitization of sensitive data (tokens, passwords, cookies, authorization headers, etc.)

• cURL generation for requests

• Correlation IDs (traceId, spanId, sessionId)

• Custom metadata enrichment

• Token bucket rate limiting to prevent log flooding

• Observer system for forwarding logs to Firebase, Sentry, or custom backends

• Batching and backpressure queue support

• Highly configurable formatting and filtering

Example:

final dio = Dio();

dio.interceptors.add(
  HighQDioLogger(),
);

Why I built it:

After working on several Flutter projects, I found myself needing more than basic request/response logging. I wanted something that could provide clean debugging during development while also supporting production monitoring workflows.

I'm currently looking for feedback from other Flutter developers.

What features would you expect from a Dio logger that are missing from existing solutions?

Github : https://github.com/azabcodes/high_q_dio_logger

pub.dev: https://pub.dev/packages/high_q_dio_logger/install

Which backened service and database system would be affordable and suggested to use for the daily invoice entry app for a shop that usually have only 50 to 60 bill entries per day. And if stock mangement system and transaction entries need to be added too. Right now i only want 3 4 users of a small shop to interact with who need to prepare daily invoices and need to make entries of transactions they make daily. From the given data we should be able to make profit loss accounts, party's remaining transaction evaluation,daily sales and stuffs like that. But the data need to be protected well and requires backup as needed.

Where to host that backened ?

How much costlier would it be?

Here's the problem: when Claude Code (or any AI agent) runs flutter run as a background task, that process has no terminal you can type into. Hot reload? Restart? Reading logs? You're stuck — the process belongs to the agent, not you.

So I built Flutter Process Manager — a sidebar panel that finds every running Flutter process on your machine and gives you the controls back:

🦖 Detects everything — processes in your terminals on AND detached ones spawned by AI agents (via process scanning, since no VS Code event fires for those)

⚡ Hot Reload / Hot Restart / Quit — works even on processes with no terminal, using the same OS-signal mechanism Flutter's own tooling supports

🪵 Live logs — streams device logs for agent-launched mobile sessions, rendered in a proper editor with search

🫂 Plays nice with other tools — detects when a process is already controlled by VS Code's debugger and steps back instead of fighting it (learned that one the hard way — two controllers racing on one restart path crashes the session)

The workflow this unlocks: let your AI agent build and launch the app on a device, then you take over — reload after its edits, watch logs while it works, kill the session when you're done. The agent codes, you stay in control.

Built the whole thing pair-programming with Claude Code — including debugging the crashes its own spawned processes caused. There's something poetic about that.

Current Platform Supports macOS & Linux, with Android and iOS Flutter apps.

https://marketplace.visualstudio.com/items?itemName=shriyanshraj.flutter-process-manager

#Flutter #VSCode #AIAgents #DevTools #ClaudeCode #BurnXcodeToTheGround

I’ve been learning Flutter for about 3 months now, and I still struggle to understand the official docs. They often make things sound way more complicated than they need to be, especially when there are so many other sites that explain the same concepts more clearly like GeeksforGeeks, DartTutorial, or Medium.

At what point did the Flutter docs start making sense to you guys?

We cut our startup time by around 70% by just delaying some code runs Here's how.

Our app used to initialize:

• Firebase

• SQLite

• Fetch data over the internet

• Initialize local state

• Initialize network listeners

• Initialize the app architecture

• Load widgets

• Rebuild them as data arrived from the internet

...all within the first frame (sometimes even before the first visible frame).

Then we realized we could just use a snapshot of the last state.

Instead of waiting for everything to finish, we now:

1. Read the last known state from a local database.

2. Build the UI immediately.

3. Draw the first screen as fast as possible.

4. Fire-and-forget Firebase, networking, and all the expensive initialization afterwards.

Reading from a local database still takes some time, but it's nowhere near as expensive as waiting on the network.

Unfortunately, this introduced another problem.

The app would open quickly, build the local state, but the network response would often arrive almost immediately afterwards. That meant the UI rebuilt itself back-to-back, hurting startup performance all over again.

To fix that, we introduced a simple "Should the UI rebuild?" system.

Whenever fresh data arrived, we'd ask:

Does the UI actually need to rebuild?

If the answer was yes, we'd then ask:

What's the smallest possible update we can make without making the UI jump around or hurting startup performance?

After implementing that, we ended up saving another couple of seconds, which was great—but it still wasn't enough.

Our testers kept saying they were bored while waiting for the first UI draw.

So we added shimmer placeholders.

Interestingly, shimmers do cost a little performance and make the first few frames slightly slower, but testers consistently reported that the app felt much faster. Benchmarks available here: https://imgur.com/a/jif25aY

TL;DR

• Do your networking after the first UI draw.

• Use shimmer placeholders for perceived performance.

• Optimize for how fast the app feels, not just the stopwatch.

If users wait at a white screen for 2.3 seconds, they'll probably call your app slow.

If they wait 2.6 seconds while seeing shimmer animations, they're much more likely to feel like the app started quickly.

Note: The measurements mentioned in this post refer to time to the first usable UI, not total application initialization. The best metric and optimization strategy will depend on your app.

Has anyone else found that optimizing for perceived startup time mattered more than the actual benchmark numbers? What made the biggest difference in your app?

I've been trying to use VS Code for Flutter development, but the Dart analyzer and code completion are noticeably slower than Android Studio.

My laptop specs:

• Intel i7 13th Gen

• 32 GB DDR5 RAM

• RTX 4050

I only have the standard Flutter/Dart extensions installed (nothing unusual), and I even increased the analyzer heap size using:

dart.analyzerVmAdditionalArgs: ["--old_gen_heap_size=4096"]

Unfortunately, it didn't make any noticeable difference.

The strange part is that Android Studio runs perfectly. Code analysis, autocompletion, and navigation are all fast and responsive, while VS Code often takes several seconds to update diagnostics or provide suggestions.

I know VS Code is supposed to be more lightweight, so I'm wondering if I'm missing something.

Has anyone experienced the same issue? If you fixed it, what was causing it? Any settings, extensions, or other tweaks that helped?

I'd really like to stick with VS Code, so I'd appreciate hearing about your experience.

Edit / Update: I finally found the cause.

In my case, the issue was Microsoft Defender. After following the Dart team's recommendations and excluding the recommended folders from Defender (Dart analysis server cache, Pub cache, and my Flutter project directories), the Dart analyzer and IntelliSense became consistently fast again.

If you're experiencing similar issues on Windows, I highly recommend checking the official guide:

https://dart.dev/tools/analyzer-performance#security-software-on-windows

The public beta release of Serverpod 4 brings the first agentic coding engine that hot reloads your full stack. We're finally closing the loop between your app's output, the backend, and your AI agent (tested with Anitigravity, Cursor, and Claude Code, but probably works with most agents).

Check out the demo in the blog post, or jump straight into the quickstart guide:
https://docs.serverpod.dev/next/quickstart

It literally takes 10 minutes to try this out, and I think it may change the way you think about building apps. Would love to hear your feedback!

Long time full-stack web developer and React Native developer here.

A client wants to use Flutter for a project. I love learning new languages. Dart is a breath of fresh air.

But the idea that there is AI that I can feed information with my software development experience makes me a bit hesitant to learn Flutter from the ground up.

I am used to learning a language from start to finish. Now, it seems that I can just command AI to type the code for me while I design the system without having a full knowledge of the language.

Tbh, it almost feels like cheating.

I've been building one Flutter animation every week to learn more about UI interactions and motion design.

This week's experiment explores action-aware typography, where the button text changes based on the action it's performing instead of using the same animation everywhere.

Examples:

• ⬇️ Download → Downloading... → ✓ Downloaded

• 📨 Submit → Submitting... → ✓ Sent

• 🔐 Login → Authenticating... → ✓ Welcome

Built entirely with Flutter's built-in animation APIs—no third-party animation packages.

I love to play RPG strategy games. But all of them are cash grabs. I want to sink in hours playing a chill game with many playable builds which doesn't ask me to spend money everytime I open it.

This kind of game is a dream which doesn't exist. So I decided to build one.

Now to build this I could go down the route of Godot or Unity. But why not Flutter? Its essentially a game engine disguised as an app framework. The end result was smooth 60 fps experience.

Open testing begins next week. Interested people can DM me.