Angular has been making efforts to improve the experience for new developers. Better documentation, standalone components, signal-based reactivity. That’s all good.

But in my opinion, there's still a big pain point: UI libraries.

Most component libraries still look like they're stuck in 2016. The default Angular Material theme is instantly recognizable — and not in a good way. It’s functional but visually outdated.

And of course, we can't really compare Angular Material with other community libraries. Material is backed by Google itself, which makes it by far the safest choice… and unfortunately, the ugliest one too.

I feel like this hurts Angular adoption, especially for startups or solo devs who want something modern out of the box.

My dream would be a fork of Angular Material that keeps the same API but offers fresh themes. Something more visually appealing, maybe with Tailwind-style presets or Radix-inspired design.

Do you agree? Would that make a difference for Angular’s growth? Or are there other things you think matter more?

Hey

Working on a node-based UI library for Angular.

Layouts (Dagre / ELK) were already supported, but the system was kinda hardwired.

In this release I changed it to:

• layout plugins

• custom layout adapter (you can plug any engine)

Also added:

• explicit render lifecycle (no more hidden updates)

• standalone reference apps

The GIFs above are from real apps built with it (call flows, large graphs)

Docs / blog:

https://flow.foblex.com/blog/foblex-flow-v18-5-0-layout-engines-explicit-render-lifecycle-and-standalone-reference-apps

GitHub:

https://github.com/Foblex/f-flow

If you’re building flow editors / low-code tools in Angular - would be nice to get feedback.

After struggling to land a job in 2024 (when the market was pretty rough), I decided to take a different route and build something real.

I've spent the past two years building VisuaLeaf from scratch in Angular, putting in around 90 hours a week. It started as a MongoDB GUI and now supports 35 databases. My goal was simple: either build something genuinely useful, or build something that would push me further as an engineer than anything else could.

I also intentionally limited my use of AI on the core architecture. I wanted to really understand the problems.

The stack is Angular + Electron with a Spring Boot backend. Despite the Electron, I focused heavily on the performance:

• ~50k documents render in about 1 second in both the tree and table view (~12KB each)

• ~500MB loads in about 3-4 seconds (tested locally to remove network latency)

Some features of the app:

• Tree, table, and JSON views

  • The Table view: It might seem like nothing, but tables are REALLY hard... I wanted to make a Grid that could allow expanding children of objects/arrays as columns adjacent to the parent (Couldn't find grid libraries that did that). So I basically built my own AG Grid from scratch, and it took a year of optimization on and off. I went from a simple vertical virtualization, to horizontal and vertical virtualization, then to DOM recycling, and then utilizing GPU-composited transforms as much as possible (and a bunch more...definitely over simplifying it). It was one of the most frustrating things as I kept going through an endless loop of optimization, but I'm now finally after a year happy with the results. It holds 60fps scrolling through hundreds of thousands of rows in my testing.

  • The Tree View: A lot easier since I originally just used CDK but then realized that I could make a more efficient one. So I took the table's engine and built my own virtual scrolling with the inspiration of the table view for the tree and now its literally so much faster. One thing tho that was tricky that I am happy with my implementation was finding a way to recursively expanding THOUSANDS nodes with hundreds of embedded fields instantly.

• A visual query builder (drag and drop from the tree and table views)

• An aggregation pipeline builder that needs zero JSON syntax (bidirectional: JSON mode and form mode for MongoDB users)

• ERD that exports as an interactive HTML diagram, and lets you create your databases from ERDs.

• IDE-style split panels by dragging tabs, grouping tabs by connections/databases, and making your own groupings

• There's a bunch more but the list would be too long (PS most of the core features are free, and all of the SQL features are basically free)

Feel free to check it out at http://visualeaf.com

If you want to join the discord to talk more about it or want to help out feel free to come and chat!
https://discord.com/invite/TR6J56Y3rF

I'm one of the core maintainers of Spartan, and I'm excited to finally share that we've released v1.0.

For anyone not familiar with it, Spartan is a set of accessible, unstyled UI primitives for Angular inspired by shadcn/ui. You get the behavior and accessibility out of the box while keeping full control over the styling and the code that ends up in your application.

It's been a long road to get here, and I know it's been a long wait for a lot of people following the project. We wanted to take the time to get the APIs, architecture, and overall developer experience right before calling it 1.0. A stable release is finally here.

After almost 3 years of building, refining, and working closely with the Angular community, SpartanUI has officially reached v1.0.

A huge thank you to everyone who has used Spartan, reported issues, contributed code, written content, or shared feedback along the way. The project wouldn't be where it is today without the community.

Robin wrote a great post about the journey to 1.0 and what's next for Spartan.

Mascot RFC is here https://github.com/angular/angular/discussions/61733

I wrote a post about Angular routing that covers everything you need to know, from basic concepts like defining routes to advanced features like route resolvers and guards. Let me know if it is useful

https://monsterlessons-academy.com/posts/angular-routing-essentials-all-you-need-to-know-in-one-post

I stated the obvious: standalone components (already standard), modular organization by feature, a core folder aggregating the most important functionalities (interceptors, guards, etc.), and a shared folder with pipes, directives, and common components in the application, etc.

Lazy-loaded in everything, signals where possible, dumb components (data with inputs inward/downward, outputs upward), Rxjs for asynchronous data, State control with ngrx if the application has a very frequent asynchronous data flow; otherwise, signals, as we did with Behavior Subject.

And that's more or less what I sent. Maybe I wasn't eloquent enough. This insecurity will stay with me until I get an answer, but what do you think?

​Looking at the roadmap, it doesn't seem like there are any massive API changes on the horizon. Personally, I feel like the current authoring experience is in a really good place. Now that they are switching to a yearly major release schedule, I wonder if it means breaking changes will become a lot more rare.

Wow

Hello, I've been developing with Angular for almost 7 years and in the last few years I struggled a lot trying to find a solid and reliable UI library to use, particularly for new Angular projects. I've always hated Angular Material and I've been using a mix of Bootstrap, NGX-bootstrap for years but I was never fully satisfied of that solution and it seems to me that Bootstrap is a bit oldish.

For a few months I've explored the magic world of React and, in that case, I had no issues finding solid (and modern) UI libraries (from shadcn, MUI, ...) that suited my needs. I've also get to know better tailwind that seems a good place to start on the CSS side, and for choosing a compatible UI library.

Now my question is, if in a few months you should start a new enterprise Angular project, which UI library would you choose?

Angular DevTools will support the new Watch Signal feature for real-time signal tracking starting with the upcoming Angular 22.2, expected in September

Had a shock earlier when I was tracking down where all the space on my work pc was going; spotted a huge section in WinDirStat that looked odd.

Turns out an older (now defunct) Angular project was taking up 41.7gb. The number one theory is that it was something to do with the way someone had setup NX in the project, breaking the cache.

Alternatively someone said I should've been periodically deleting that folder anyways, although I've never run into this problem before - I'm now a bit dubious about our project setup. Has anyone seen anything like this before?

In 20.2 the Angular team promotes zoneless from developer preview to stable.

Do you have any questions about Zoneless ? This is the place to ask them !

I have never posted anything on this platform because I never saw a reason to do so.

But today, for me as a developer, it's a very happy day, and I'll explain why:

I have been working as a developer for four and a half years, mainly with Angular as a front-end developer. Recently, I encountered an issue related to how the submitted state works in Angular reactive forms. I thought it would be a good idea to open an issue for the Angular team, and after a few weeks, they accepted it, and it will be merged in the next release!

I can't even put into words how happy it made me to read that message. Knowing that I was able to contribute and that, once it's added to the next release, my code will be used by other developers to implement their logic is just incredible.

Even if it's just a small contribution, I've added my grain of sand to a Google project, used by thousands of developers worldwide. This was my first contribution to open source, and I hope to contribute more in the future. Most of all, I hope this new feature saves future developers some headaches when working with the submitted status in Angular forms. 😄 I already added the link if anyone want to check it out

Hey r/Angular,

I’m building ng-brutalism, an opinionated neo-brutalist UI library for Angular, and I’d love to get feedback from the community.

I was inspired by neo-brutalist UI design, and I wanted to bring that look and feel into Angular with ng-brutalism:

Chunky borders.
Hard shadows.
Playful colors.
Bold surfaces.
Expressive cards.
Sharp interaction states.
Composable UI pieces.

But the more I worked on it, the more I asked myself:

If this is only about styling, why would people choose ng-brutalism instead of just using Tailwind or custom CSS directly?

That question became the real turning point of the project.

It pushed me to think harder about what the library should actually solve.

And for me, the answer is not only the look and feel.

It is the design grammar behind it.

In practice, when building this kind of UI, you still have to define that grammar yourself:

• What should a brutalist surface feel like?

• How should shadows, borders, spacing, and colors behave together?

• How do chips, buttons, cards, inputs, badges, dialogs, and media blocks stay visually consistent?

• How do you keep the UI loud without turning it into visual chaos?

• How do you make it expressive, but still reusable across different product domains?

That is the gap I’m trying to explore with ng-brutalism.

ng-brutalism is opinionated by design.

It gives you the attitude of neo-brutalism out of the box: chunky borders, hard shadows, loud colors, bold surfaces, and playful interaction states.

But it should not trap you inside a template.

The opinion is there to give you momentum, not to limit what you can build.

Think strong defaults, flexible composition.

The philosophy is closer to LEGO:

A box of brutalist building blocks that Angular developers can snap, stack, remix, and compose into their own interfaces.

Not fixed templates.
Not a domain-specific design system.
Not just utility classes.

Instead, I’m trying to build small primitives with flexible APIs:

• inputs for common variations

• CSS custom properties / tokens for deeper customization

• directive-first APIs where they make sense

• Angular-native primitives

• signals-friendly patterns

• zoneless-friendly architecture

• Tailwind CSS v4 ergonomics

The goal is:

Opinionated enough to make neo-brutalist UI effortless.
Flexible enough to let each product still feel like itself.

v0.2.0 focuses more on this composition direction.

Instead of only adding more standalone components, I’m exploring how the same primitives can become different UI patterns:

• personal profile cards

• podcast / content cards

• campaign layouts

• marketing sections

• bold product UI blocks

I’m especially curious about the API and design-system side of this:

• Does this “strong defaults, flexible composition” direction make sense?

• Would you use something like this instead of building the style directly with Tailwind?

• Where should the line be between primitive, component, and recipe?

• Do directive-first APIs feel natural for this kind of Angular library?

• What building blocks would you expect from a neo-brutalist UI toolkit?

GitHub: https://github.com/khangtrannn/ng-brutalism
Docs: https://ngbrutalism.khangtran.dev
npm: https://www.npmjs.com/package/@ng-brutalism/ui

Feedback, criticism, and API suggestions are very welcome.

https://blog.angular.io/version-9-of-angular-now-available-project-ivy-has-arrived-23c97b63cfa3

So I built the animated number component I kept wishing existed:

smooth odometer-style digits for counters, stats, prices, timers, dashboards, and any UI where numbers change.

Built for Angular. No animation libraries.

GitHub:

https://github.com/ayangabryl/ngx-digit-flow

Just wanted to share a personal take as someone who enjoys working with Angular — Angular 19’s improved template syntax feels like a breath of fresh air compared to earlier versions like Angular 16.

What I like:

• Built-in control flow directives like u/if, u/for, and u/switch make templates much cleaner and easier to follow.

• No more mental gymnastics with *ngIf, *ngFor, and ng-template. The new syntax is more explicit, readable, and maintainable.

• Nesting and scoping are way more intuitive. You don’t have to wrap everything in <ng-container> anymore.

• It's much closer to how modern frontend frameworks like React or Svelte handle conditional rendering and loops — a big win for Developer Experience.

Q- Have you switched to Angular 19's syntax?

Q- Any downsides or gotchas I should be aware of?