Working with Dart?

Dart SDK bump or null-safety migration stuck? We finish it.

Dart is the language that carries Flutter, and a Dart problem usually arrives dressed as a Flutter build failure. We work on the language itself: sound null safety migrations that stalled at 60 percent, Future and Stream chains that lock the UI, and pub constraints that refuse to resolve on the first clean checkout.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

dart-analyze.log

still failing

What it is

Dart at a glance

Dart is a client-optimized, statically typed language created at Google and first released in 2011. The language reached sound null safety with version 2.12 in 2021 and continues to evolve on an annual cadence. It compiles to native machine code for mobile and desktop and to JavaScript or WebAssembly for the web.

Outside of Google, the language is used almost entirely with Flutter: iOS, Android, desktop and web applications written in a single codebase. The pub.dev package manager hosts the ecosystem, and the dart command drives the compiler, formatter, analyzer, test runner and the devtools used for profiling Flutter apps.

Type
Client-optimized language with AOT and JIT compilation
First released
2011
License
BSD 3-Clause
Maintained by
Google
Typically used for
Flutter apps for iOS, Android, desktop and web, command-line tools, Dart-only backends

The honest version

Dart pros and cons

No technology is all upside. This is where Dart earns its place and where it tends to cause trouble.

Where Dart is strong

  • Sound null safetyThe type system treats nullable and non-nullable as distinct, and the compiler enforces it. Once a codebase is fully migrated, a huge class of runtime nulls simply stops happening.
  • Hot reload during developmentChanges in a running Flutter app apply in under a second with state preserved. Iteration on a layout or a reducer feels close to live editing rather than build-and-restart.
  • AOT compilation for releaseRelease builds compile to native machine code with predictable performance. No JIT warm-up is needed on the first screen, which matters for startup time on mobile.
  • A clean async modelasync and await are built into the language, Future and Stream are first-class, and the async* generator syntax makes stream producers easy to write without a library.
  • One toolchaindart analyze, dart format, dart test, dart compile and pub ship together. New projects do not have to pick a formatter and argue about it for a sprint.
  • A focused standard libraryCollections, isolates, async primitives and I/O are designed around the language. Code reads consistently across different packages because the base APIs are opinionated.

Where Dart bites

  • Dart lives almost entirely for FlutterOutside of Flutter the ecosystem is small, and tooling for Dart-only backends exists but is thin. Picking Dart for a server implies accepting a narrower library pool than Go or Node.
  • Null safety migration takes timePorting a pre-2.12 app to sound null safety surfaces hundreds of warnings, especially around late variables and legacy JSON models. A half-finished migration is worse than either state.
  • Package resolution can be brittlePub's version solver is strict, and two popular packages demanding conflicting versions of a shared dependency stop pub get cold. The fix is rarely a one-line change.
  • Error messages for generics are longA mismatched generic type in a nested builder prints a type error that reads like a sentence of symbols. Readable messages have improved but are still dense.
  • LateInitializationError at runtimelate variables defer null-safety checks to first access. If the initialization path is skipped on one code route, the error only shows up in production under the right conditions.
  • Hiring is a Flutter hiring problemNobody picks up Dart on an unrelated project, so the hiring pool is the Flutter community rather than a broad language community. Teams who need other skills on the same engineer end up training rather than hiring.

Sound familiar?

Common Dart problems we fix

The Dart problems that bring people to us, and what you have once each one is fixed.

Null check operator used on a null value

Runtime nulls still reach production

A ! operator used on a value that is sometimes null, usually inside JSON parsing or after an await where the surrounding state changed. Sound null safety catches most of these, but not the ones hidden by late or !

Null origins traced and fixed

LateInitializationError: Field 'controller' has not been initialized

A late variable read before assignment

A controller declared late because it is set in initState, which gets read on a code path that runs before initState finishes or in a test that skips the init step entirely.

Initialization reaches every read

pub get: version solving failed

Dependencies will not resolve

Two packages demanding incompatible versions of a shared library, often after a major Flutter upgrade that pulled in a new constraint. The fix is often one package that needs a maintainer release.

Lockfile that resolves on a clean checkout

Future already completed

A completer finishes twice

A Completer used for a one-shot result that gets completed from two code paths, usually a success handler and an error handler that both fire on a borderline response.

Completers finish exactly once

Dart SDK version is 3.2.0, required >=3.5.0

The project is stuck on an old SDK

A codebase that has not bumped in a year, plugins that now require a newer SDK, and a developer who tried the upgrade once and reverted when the migration flagged too many warnings.

Running on current stable with warnings addressed

null-safety: 40% migrated

Null-safety migration stalled

A mix of null-safe and legacy files, dart migrate output ignored halfway through, and new code written in both styles depending on who wrote it.

Entire codebase on sound null safety

avoid_dynamic_calls

Dynamic typing hides bugs

A section of the codebase that uses dynamic as an escape hatch, usually around deserialization, which bypasses the type system and produces runtime errors the analyzer could have caught.

Dynamic replaced with concrete types

handover: no clean build

Dart project from a previous developer

A repository that depends on a specific analyzer version, a global pub cache, or a plugin that has been removed from pub.dev. Nobody can run dart analyze without setup instructions that do not exist.

Project builds green on a fresh laptop

What we do

Dart help, from one error to ongoing care

Ping us about one failing Future, or hand over the Dart codebase and we work it from the SDK upward.

Rescue
A project that will not compile after an SDK bump, a Future chain that deadlocks the UI, or a null-safety error nobody can track down. We stabilize the build and the behavior first.
Null-safety migration
Finishing a stalled dart migrate, replacing late with proper initialization where it matters, and adopting sound null safety across the whole codebase in stages.
Async and Streams
Future and Stream patterns reviewed, Completer misuse rooted out, StreamController lifecycles made explicit, and isolates added where they earn their keep.
SDK upgrades
Moves between Dart major versions, with analyzer warnings addressed, deprecated APIs replaced, and plugins bumped against the target SDK on a branch.
Code review and architecture
A senior pair of eyes on type design, generic use, package boundaries and the balance between clean API and Dart idiom.
Managed Tech
Steady work on SDK and plugin updates, analyzer configuration tuning, and the ongoing effort of keeping a Dart codebase healthy as Flutter and Dart ship releases on their own schedule.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Dart alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Dart questions

Something else? Call+1 737 727 7327

How do we finish a stalled null-safety migration?

By running dart migrate on a fresh branch, accepting the suggestions that are clearly correct, and manually reviewing every late keyword the tool inserts. The late escape hatch should be rare. Most fields are either nullable or initialized at the right point, and treating them that way surfaces the real nulls the migration was meant to find. We work through a codebase a few hundred warnings at a time until the analyzer runs clean.

Why do we get LateInitializationError in production?

A late variable postpones the null check until the first read, and some code path is reading before any code path has written. We trace the read sites, confirm which path runs first, and either initialize the field in the constructor or convert it to a nullable with explicit handling on the read side.

Can Dart be used for a backend without Flutter?

Technically yes, with the shelf server library and the aot_snapshot deployment story, but we rarely recommend it. The ecosystem for Dart servers is thin, hiring is harder than any of the mainstream backend languages, and the gains over Go or Node are small. We only steer teams toward Dart on the server when they already have a strong Flutter team and want to share domain code.

Why does pub get fail with version solving errors?

Because two packages in the tree demand incompatible versions of a shared dependency, and pub refuses to pick one over the other. The fix is either a newer release of one of the packages, replacing one of them with an alternative, or writing a local override while the maintainer catches up. We identify the conflict, propose the lowest-risk path, and apply it in a reviewable commit.

How do we upgrade an old Dart project to a modern SDK?

On a branch, in stages. First bump the SDK constraint and run dart analyze to see what the compiler now objects to, then handle null safety, then update packages in small groups so a bad version shows up early. We run tests between every stage and only merge when the project builds and behaves the same as before.

How much does Dart help cost?

The quote is on the house. Describe what the analyzer or the runtime is reporting, and a price arrives before any work is booked.

Free estimate

Dart code giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.