Changelog

Most programming courses assume you know what a computer is, what binary means, and what “running a program” involves. The new What Is Programming and Computers course teaches those ideas from first principles, so beginners arrive at their first programming course already understanding the vocabulary.

The course walks from hardware to high-level languages: CPUs and memory, binary and hexadecimal, what programming is, the building blocks every language shares, and how code becomes a running program. Each lesson is short and reinforced with a quiz, matching, true-or-false, fill-in-the-blank, or binary converter exercise.

After completing the course, you can:

• Explain what a CPU does and how fetch-decode-execute works
• Read binary and hexadecimal and reason about how data is stored
• Recognize variables, types, conditionals, loops, collections, and functions in any language
• Tell compiled and interpreted languages apart

Start learning

TypeScript is the language most developers reach for when building web applications, and understanding its type system is the difference between fighting your editor and having it work for you. The new TypeScript course teaches the language from first principles, with every concept paired with a hands-on coding challenge you solve directly in the browser.

You start with variables and basic types, then build through functions, objects, classes, and error handling. The second half covers generics, async/await, utility types, and advanced patterns like discriminated unions and type guards. Every lesson is a short, focused read followed by a code challenge where you apply the concept in a different context than the lesson itself, so you are practicing real understanding rather than copying examples.

After completing the course, you can:

• Use TypeScript’s type system to catch bugs before runtime
• Write generic functions and interfaces that stay type-safe
• Handle async operations cleanly with Promises and async/await
• Apply utility types like Partial, Pick, Omit, and ReturnType
• Use narrowing, type guards, and discriminated unions for complex data

Start learning TypeScript

Your dashboard now tracks daily learning streaks. Finish a lesson each day to keep it going, and earn charges that save your streak when life gets in the way.

Daily Streaks

Finish one lesson per day. Your streak counter and a five-day activity timeline live right on the dashboard.

Streak Charges

Every active day earns a charge, up to two. Miss a day and a charge kicks in automatically to keep your streak alive.

Complete a lesson in any course to start your streak. Head to your dashboard to see it in action.

APIs, databases, caches, queues, load balancers. These building blocks still decide whether software holds up in production, even in an AI-first workflow. The new System Design course shows how they fit together so you can use AI to move faster without losing architectural judgment, from requirements and tradeoffs to observability and security.

You start with the fundamentals of how systems communicate, then build up through storage, scaling, and reliability. Interactive exercises let you practice key concepts like choosing between SQL and NoSQL, designing caching policies, and reasoning about the CAP theorem. After completing the course, you can:

• Design REST APIs with clear contracts and versioning
• Pick the right database for a given workload
• Choose caching, sharding, and replication approaches
• Use message queues to decouple services
• Reason about tradeoffs in distributed systems

Start learning System Design

This release focuses on three things: latest stable Flutter, simpler routing with go_router, and a more agentic development setup.

Latest Stable Flutter

Flutter Kit now targets Flutter 3.41.2, with updated SDK constraints (Dart ^3.9.0, Flutter >=3.41.2) and refreshed generated platform files. This keeps new projects aligned with current stable behavior out of the box, and reduces setup drift between local development and CI.

go_router by Default

Our custom navigation worked and gave us tight control, but most new feature requests kept pulling toward plug-and-play expectations. To make extension simpler for more teams, we moved the routing foundation to go_router.

Route definitions now use GoRoute and RouteBase, while the context-free RouterService stays in place as a thin wrapper over go, push, replace, canPop, and pop. The result is a more familiar routing model with less custom surface area to maintain.

Agentic Development

Alongside the routing update, we tightened routing safety with a more robust 404 exception flow and redirect-loop protection, and aligned navigation tests with the go_router behavior.

We also reworked documentation and AI guidance around agentic workflows. Core conventions are centralized in agents.md, reusable playbooks live in .claude/skills, and the docs now include a generalized Agentic Development guide instead of editor-specific instructions.

Every codebase has duplication hiding in plain sight. The new D.R.Y. course teaches you to recognize when the same logic appears in slightly different forms and how to consolidate it into clean, reusable code, without over-abstracting.

Through interactive TypeScript challenges, you’ll build the judgment to know when duplication is a real problem and how to fix it. After completing the course, you can:

• Spot hidden duplication that others miss
• Consolidate similar logic into single, reusable functions
• Reduce the surface area for bugs
• Make changes in one place instead of hunting across files

Start learning D.R.Y.

Taking courses just got a major upgrade. This release brings a redesigned course layout, audio feedback during exercises, and a polished completion experience that celebrates your progress.

Redesigned Course Layout

The course learning page has been rebuilt from the ground up. A cleaner layout keeps the content front and center while making navigation more intuitive. The lesson selector now shows your progress through each module at a glance.

On mobile, the experience adapts to smaller screens with navigation elements that resize appropriately and interactive sections that stack below the content.

Sound Effects for Interactive Exercises

Quizzes, fill-in-the-blank, and matching exercises now play audio feedback when you answer. Correct answers get a satisfying confirmation sound, while mistakes get a gentle nudge to try again.

The result is a more tactile learning experience that reinforces your progress without being distracting. Sounds can be toggled off if you prefer silence.

Lesson Completion Celebration

Finishing a lesson triggers a completion modal that shows your progress through the current module. When you complete an entire module, confetti fills the screen and you get the option to share your achievement on X.

The progress bar animates as you advance, giving you a clear visual of how far you’ve come. You can continue to the next lesson directly from the modal or stay on the current page to review.

The S.O.L.I.D. course teaches the five principles that help you understand how software should be structured. But this isn’t about memorizing rules. It’s about building the intuition that lets you guide AI tools effectively and recognize good solutions from bad ones.

When you understand Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, you can:

• Recognize when a class is doing too much
• Structure code that’s easier to change
• Understand why certain patterns exist and when to use them
• Spot potential issues before they grow

Start learning S.O.L.I.D.

Your certificates display the name from your profile, but until now there was no way to change it after signing up. This release adds a Profile section to Settings where you can update your display name anytime.

Profile Settings

Head to Settings and you’ll find a new Profile section at the top. Enter the name you want to appear on your certificates, click Save, and you’re done. The change takes effect immediately for any certificates you download afterward.

The result is full control over how your name appears on completion certificates, without needing to contact support.

Quick Access from Certificates

When viewing a completed course’s certificate, a subtle link now appears below the download button: “Wrong name? Update it in settings.” One click takes you directly to the Profile section.

This makes it easy to fix your name right when you notice an issue, rather than hunting through menus.

Switching between lessons now happens instantly. Instead of waiting for a full page reload each time you navigate, lessons load in the background while you stay in flow. This release also brings improvements to the mobile experience.

Instant Lesson Switching

When you select a lesson from the dropdown, the content loads without a page refresh. Your browser history still works as expected (back and forward buttons navigate between lessons), and progress tracking updates in real time as you complete lessons.

The result is a smoother learning experience, especially when jumping between related lessons or reviewing previous material.

Smarter Loading States

A new loading overlay appears during lesson transitions, giving you visual feedback while content loads. The overlay is designed to feel fast: it shows immediately but fades smoothly once the new lesson is ready.

When errors occur (network issues, access problems), you’ll see a clear message with a retry option instead of a broken page.

Mobile Layout Improvements

The course learning page now adapts better to smaller screens. Navigation elements resize appropriately, and the interactive section stacks below the content instead of fighting for horizontal space.

Our existing courses are great for the “Big Picture,” but sometimes you don’t need a 10-hour course. You just need to understand the one thing standing in your way right now.

The Problem: “I know A, but I don’t get B.”

Traditional courses often force you to start from zero. If you already know Future in Dart but just want to learn about Stream , you shouldn’t have to take a 10 hour Dart course just to get that core knowledge.

The Solution: Just-in-Time Learning

Our new AI Learning Assistant is designed to meet you exactly where your knowledge ends.

Deep-Dive on Demand: Tell the AI exactly what you already know and what you’re struggling with. It will generate a Targeted Lesson that skips the fluff and focuses entirely on your specific bottleneck.

Interactive Context: Every custom lesson comes with a quiz or code challenge designed specifically for that topic, so you can prove to yourself that you’ve actually mastered the “missing piece.”

How to Use It

Try it out, leave feedback, this is still very early but we now have a foundation for creating your personalized learning platform.

We’ve completely revamped our logging and tracing approach using the wide events philosophy. This is an internal improvement that helps us debug issues faster and maintain the platform more effectively.

Instead of scattered log lines that require searching through multiple services, we now capture comprehensive, structured events with all the context we need. When something goes wrong, we can quickly identify the root cause and fix it faster, which means fewer bugs and better reliability for you.

This improved observability is especially valuable as we continue to add features, where understanding the full request lifecycle helps us ensure everything works smoothly.

One of the best parts of Flutter development is hot reload, the ability to see your changes instantly without losing your app’s state. Until now, this experience was missing from our interactive editor.

Instant Updates

Hot reload is now available in the Flutter course! When you make changes to your code, you’ll see updates instantly without losing your app’s state. This brings the Flutter development experience you know and love directly into your browser.

No more waiting for full page refreshes or losing your place in the app. Just code, save, and see your changes appear immediately. This makes experimenting and iterating on your code much faster and more enjoyable.

We’ve always believed that feedback is essential for improving our courses. While we have a discord where we’ve been collecting feedback for a while, there is still a little friction of switching to another platform. That’s why we built a comprehensive feedback system directly into every lesson.

Share Your Thoughts

Now, when you’re learning, you can share feedback or report issues right from the lesson page. The feedback popup lets you also:

• Add screenshots - Paste images or upload files to show exactly what you’re seeing
• Stay anonymous - Submit feedback anonymously if you prefer

Better Course Improvements

This feedback system helps us understand what’s working and what needs improvement. Every piece of feedback is valuable, and we review it all to make our courses better.

Your feedback is now just a click away. We’re excited to hear from you and use your insights to create the best learning experience possible.

Our mission from the very beginning has been to be a one-stop shop for anybody to be able to build apps. The key words there are “anybody” and “build apps”. Whether you’ve never touched code before, or you’re coming from a different language, or you’ve tried Flutter but want to be more confident, we now support all of you.

And the second important keyword is to build apps.

Video courses can be used as entertainment. I would argue that probably more than 50% of the time, they are. I know I have done it before as well.

Hungrimind doesn’t work like that. Our platform doesn’t allow you to be a bystander. You can’t just watch a lesson about Encapsulation and pretend that you learned it. On Hungrimind, you have to show us that you learned it to move on to the next lesson.

With the Dart Course completed, anybody can learn to build apps. All you have to decide is whether to become a member; we’ll handle the rest.

The Features

The Dart Course follows a similar structure to the Flutter Course: Learn the topic on the left, show us that you learned it on the right with an interactive challenge.

In order to achieve this, the Dart Course has a new Interactive Terminal. Not only can you run your Dart program directly in the browser, but you can also interact with and give it inputs!

There are almost 100 interactive lessons in this course, and we made the first 22 completely free! So, give it a try.

If you like it, we’d love to see you become a member, and if you don’t, please let us know why.

As with all our courses, the goal is to create the Best Dart Course on the internet. We believe we accomplished this, and most people who try it agree.

The Functions module is now live. This module covers the fundamental concepts of functions in Dart, including how to define and call functions, how to pass arguments to functions, and how to return values from functions.

The next module will be Object-Oriented Programming.

Collections are a way to store multiple items in a single variable. Programs usually need to handle a lot of data, so collections are a way to group related data together.

They are one of the mostly used data structures in programming.

This module covers the fundamental concepts of collections in Dart, including Lists, Maps, and Sets.

The next module will be Functions.

An LSP is a Language Server Protocol. A language server is a server that provides language-specific features to an editor. This is how we get autocomplete, hover tooltips, and other language-specific features in the browser editor.

Before this update, our configuration for LSP was too eager to show completions. It would show auto-completions in cases where you wouldn’t want them. This made coding in the browser less enjoyable than it could be.

After this update, the LSP is much more selective about when it shows completions. It will only show completions when you are after a trigger character, or when you have typed at least 1-2 characters.

The Dart Course has been updated to version 3.10. Not much meaningful has changed with the lessons, since the Classes module is still in development.

However, the version is 3.10, which means you can write dot shorthand in the browser editor.

The Control Flow Module is now live. This module covers the fundamental concepts of control flow in Dart, including conditionals, loops, and switch statements.

The next module will be Collections.

We’re excited to announce the launch of the Dart Course 0.1. This is the first interactive Dart course where you code, test, and build apps directly in your browser, with guidance every step of the way.

Interactive Learning Experience

Every lesson in this course is interactive. You write, run, and test code right here in your browser. Every concept is paired with live exercises where you get instant feedback as you code.

What’s Included

This initial release comes with over 35 lessons, with 22 lessons being completely free.

It starts from the very beginning, even before the Dart language.

1. What is a computer or program?
2. Binary -> Assembly -> Dart
3. Structure of a Dart Program
4. Variables
5. Strings
6. Numbers
7. Operators
8. Null Safety

The topics above are live and available to learn right now. But more topics are added every week. Here is what you can expect:

1. Control Flow
2. Functions
3. Collections
4. Object-Oriented Programming
5. Asynchronous Programming
6. Dart Ecosystem
7. Testing

Try the Dart Course now

The last impression you leave is the most important one. And the ending of our course was lacking and a bit cringe.

We created a proper review system that let’s you leave a rating and review. We also cleaned up the lesson content to make it more direct and to the point.

But even more importantly, we now collect these reviews and can use them to improve the course over time. This is a big step for us and we are excited to see the feedback.

We’re excited to announce that we now offer Purchasing Power Parity (PPP) pricing for users in India, Brazil, Egypt and Turkey.

Global Accessibility

PPP pricing adjusts our prices to reflect the economic conditions in different regions. This makes our membership accessible in lower-income countries.

Our goal is to make the highest quality Flutter education accessible worldwide. We’re committed to expanding PPP pricing to other regions where it makes sense, ensuring developers everywhere can access the tools they need to succeed.

Just visit our site and you’ll see the pricing that’s right for your region.

Request PPP Pricing for Your Country

Want PPP pricing for your country? Send us an email at support@hungrimind.com and let us know where you’re located. We’re actively working on expanding to more regions.

AI tools are becoming essential for Flutter development, but getting consistent, high-quality results requires proper configuration. We’ve made significant improvements to help you get the most out of AI-powered development.

Refined Flutter Kit AI Rules

We’ve completely refined the Flutter Kit AI rules to have a deeper understanding of the MVVM architecture and production patterns. The rules now provide much more specific guidance on:

• Proper dependency injection patterns
• Navigation handling
• State management best practices
• Improved folder structure guidelines

When you ask AI to implement features, you should now get significantly more consistent results that follow the Flutter Kit’s standards.

Enhanced Documentation About AI

The Flutter Kit documentation now includes links and insights into Flutter’s new AI rules template. We also provide some context on why we’re not using their rules, but it might still be valuable to be aware of.

We have been working on Hungrimind full-time for almost a year. During this time, we have been focusing all our effort on creating the very best Flutter learning experience that we can.

Since then, we have added a few more products like the Flutter Kit and Kubernetes Kit. Our goals have always been bigger than just teaching Flutter, but the way we communicate this goal was lacking.

We started as a Flutter Course, but our goal has been way bigger than just teaching Flutter. Our goal is to help you build good products (which includes learning Flutter as the first step). But there are many more steps to it. And the only way to learn is to build. With the courses, kits, and community.

And this is why we introduced the Hungrimind Membership, so you can access all the resources we have created to help you do that.

Check out the new landing page yourself!

Resolved a routing conflict in BestRouterConfig where the initialRouteInformation would ignore deep-link URLs from the platform. The router now correctly prioritizes the platform’s URL for deep links, while falling back to the RouterService state for default (/) launches. This ensures both web deep-linking and pre-configured app start-up routes function as expected.

Before

1
class BestRouterConfig extends RouterConfig<Object> {
2
  BestRouterConfig({required RouterService routerService})
3
    : super(
4
        routerDelegate: AppRouterDelegate(routerService: routerService),
5
        routeInformationProvider: PlatformRouteInformationProvider(
6
          initialRouteInformation: RouteInformation(
7
            uri: Uri.parse(
8
              routerService.navigationStack.value.last.uri.toString(),
9
            ),
10
          ),
11
        ),
12
        backButtonDispatcher: RootBackButtonDispatcher(),
13
        routeInformationParser: AppRouteInformationParser(
14
          routes: routerService.supportedRoutes,
15
        ),
16
      );
17
}

After

1
class BestRouterConfig extends RouterConfig<Object> {
2
  BestRouterConfig({required RouterService routerService})
3
    : super(
4
        routerDelegate: AppRouterDelegate(routerService: routerService),
5
        routeInformationProvider: _createRouteInformationProvider(
6
          routerService,
7
        ),
8
        backButtonDispatcher: RootBackButtonDispatcher(),
9
        routeInformationParser: AppRouteInformationParser(
10
          routes: routerService.supportedRoutes,
11
        ),
12
      );
13

14
  static PlatformRouteInformationProvider _createRouteInformationProvider(
15
    RouterService routerService,
16
  ) {
17
    final String platformInitialRoute =
18
        PlatformDispatcher.instance.defaultRouteName;
19

20
    final String appInitialRoute = routerService.navigationStack.value.last.uri
21
        .toString();
22

23
    final String initialLocation =
24
        (platformInitialRoute == '/' && appInitialRoute != '/')
25
        ? appInitialRoute
26
        : platformInitialRoute;
27

28
    return PlatformRouteInformationProvider(
29
      initialRouteInformation: RouteInformation(
30
        uri: Uri.parse(initialLocation),
31
      ),
32
    );
33
  }
34
}

Articles should be good. They should deliver high value, look nice, and be entertaining to read.

We Removed Articles

We removed many articles. Some were launch articles that didn’t provide much value. Others were videos that were transcribed into articles.

Those articles did not meet our quality bar.

We have purged our articles to make space for the articles that matter.

New Layout And Thumbnails

To go along with the article quality improvements, we also updated the thumbnails and the layout of the article page.

Enjoy better quality free content!

As developers, we dislike situations where information is not transparent enough. We felt this for our Flutter Kit and Kubernetes Kit. We have detailed documentation, but we didn’t show it to you until you made a purchase.

Now we do.

Open Kit Documentation

The documentation is a key part of the kits. They teach how you would use the kits, how you would extend them, and just general knowledge of the topic.

So, after long consideration, we decided to make the documentation publicly available. You will now see an option in the Kit landing pages to explore the documentation.

Once you have logged in, the dashboard is the first thing you see every time you visit. Because of this, it must showcase what you are looking for in a good way. So here are some new updates.

New Structure

The new structure focuses on showing the most important things at the top. First, if you haven’t joined the Discord community, it will show a banner. This goes away once you join.

Then the main thing you see is all your products, letting you continue your learning and building journey.

What’s New Popup

From feedback, we have heard that it’s hard to know when our products have been updated. Two days ago, we shipped a changelog, but without clicking into that page, you might still miss it. Now, if there are any changes, you will see a pop-up of the last three updates and a button to see more details.

A month ago we updated the Flutter Kit documentation. And following the same guidelines, we updated the Kubernetes Kit documentation.

• New side bar look and organization to make it easier to find what you’re looking for
• Updated structure using the Diataxis Framework
• Guided Tour to give a more thorough overview of the important features
• Better and more explanations in most documents
• Cleaner and updated UI

September through December is the time to lock in. We are starting with a big shift to become a more cohesive brand with a professional look and feel.

Design

The course has been our focus, to make it really stand out as a premium product, and be undoubtedly “The Best Flutter Course On The Internet”. But the rest of the website did not match the quality … until now.

We call our new design “Modern Analog”. It’s a combination of a modern look and feel with a touch of analog, to give it a more human and personal feel. The landing page looks professional and matches the rest of the website.

But this update is a major overhaul of the entire platform. The articles and documentation have been updated to feel professional from the first iteration of the website.

Changelog

We now have a changelog page. We received feedback that some people are reluctant to subscribe because they don’t know what the future holds.

Robert and I don’t do a good job of communicating the changes we make to the product. We have been consistently adding new features and improving the product since October 2022.

This is a project that is a collection of our work together. Hungrimind is a lifelong project of everything that we learn and teach. And the best way to show this is not by making promises, but by showing proof of previous consistent improvements.

• New side bar look and organization to make it easier to find what you’re looking for
• Updated structure using the Diataxis Framework
• Guided Tour to give a more thorough overview of the important features
• Better and more explanations in most documents
• Cleaner and updated UI

This is the initial release of the Kubernetes Kit. It includes all the core features that we use in production, such as MetalLB Load Balancer, Nginx Ingress, SSL Certificates, Monitoring, Backup to AWS, Redis Caching, Certificate Managers, and more.

This new structure is more consistent by using the <product> <action> syntax. To use the new command, update your CLI by running:

1
npm install -g @hungrimind/hungrimind-cli

The initialRouteInformation in best_router.dart now uses the RouterService path instead of a default value.

Translation Without Context

You can now access a static instance of your translation using the static Translate class.

Example:

1
print(Translate.current.appName);

New Internal Notification System

By using locator<NotifyService>, you now have access to a service to either show a toast or initiate haptic feedback (vibration).

Before migration:

1
toastService.showToast(
2
  'This is a toast message',
3
);

After migration:

1
notifyService.setToastEvent(
2
  ToastEventSuccess(message: Translate.current.errorGeneric),
3
);

Haptic Feedback

Using the new notification system, you can now initiate haptic feedback.

1
notifyService.setHapticFeedbackEvent(HapticFeedbackEvent.success);

Updated Dart Formatter

We updated the formatter to better respect trailing commas.

1
formatter:
2
  trailing_commas: preserve

This is the initial release of the Flutter Kit. It includes all the core features that we use in production, such as MVVM Architecture, Routing, and more.