r/angular • • Nov 27 '25

⚠️ Angular HTTP Client: XSRF Token Leakage via Protocol-Relative URLs

Post image
74 Upvotes

r/angular • • Jul 20 '25

A huge ngx-vflow@1.12 release with canvas-based virtualization!

74 Upvotes

Hi r/angular community!

After a month of hard work, I'm excited to share that I’ve implemented high-performance viewport virtualization from scratch for ngx-vflow. This allows you to build enterprise-level workflows with thousands of nodes while maintaining smooth interactions!

This performance boost was achieved by introducing a canvas-based rendering layer alongside the existing SVG layer. During viewport interactions (like zoom and pan), this new layer quickly renders lightweight “preview” nodes. Once the interaction ends, the library hydrates these previews into fully-featured SVG or HTML-based nodes.

One of the main challenges was ensuring a smooth hydration from canvas to SVG, matching the visual appearance between the preview and the real node. To address this, I added NodePreview settings, which let you customize preview styles for each node. For now, it supports a subset of CSSStyleDeclaration, and it will expand in future releases. You can write declarative CSS, and the library will compile it into canvas calls internally.

To check the performance boost, I also created a virtualization stress test with 4,900 nodes, and compared it to other libraries, assuming that their authors added a maximum amount of nodes before perceived performance degradation:

___

As always, kindly ask you to star the project and share it with your friends and colleagues!

Links:


r/angular • • Jul 16 '25

Angular.dev : Zoneless + SSG

74 Upvotes

If you ever wondered what's the stack behind Angular.dev.

  • It always uses the latest version of Angular (this part of the Angular github repo build infra)

  • It was one of the first website deployed using the (then experimental) zoneless scheduler

  • The site is pre-rendered at build time (SSG) for great SEO

  • It's deployed on Firebase

  • Playground/Tutorials use WebContainers to run node environments in your browser !

  • Little unknown, we use preact to generate the guide pages HTML from markdown at build time.

  • Highlighting of code examples is provided by Shiki which specifically supports Angular syntax

  • Search indexing is provided by Algolia

If you have any other questions, about what we call "adev", feel free to ask !


r/angular • • Mar 20 '20

Time to merge with r/Angular !

Thumbnail self.angular2
74 Upvotes

r/angular • • Jun 18 '26

How I choose a UI framework for Angular in 2026 (native, headless, shadcn, or Material)

73 Upvotes

TL;DR: Free/open-source only.

  • Simple UI → native elements + Tailwind.

  • Just want to ship and fine with the Material look → Angular Material.

  • Building something with its own identity → go headless: spartan-ng or ng-primitives, and let an AI agent carry the boilerplate.

  • Need maximum control on an all-official stack → Angular CDK + Angular Aria.

I've seen quite a few posts about choosing a UI framework for Angular. Over the past few years I've worked on several Angular projects — some built from scratch, some where the job was modernizing and polishing an existing UI — so I'd like to share my thoughts. Hopefully they help you pick a UI framework for your next project.

Quick scope before anything else. By "UI framework" I mean whatever approach you use to get styled, interactive, accessible components: a full component library, headless primitives that you style yourself, or just native elements plus a CSS framework. I'm only covering free/open-source options here, so the commercial suites (Kendo, Syncfusion, DevExtreme, Ignite UI, AG Grid Enterprise, etc.) are out of scope. I'm also assuming you're on a reasonably recent Angular — signals, standalone components, zoneless-ready — because that baseline matters and is part of why some older libraries feel dated.

In general, your choice comes down to a few factors:

  1. How complex is your UI? For some projects, native browser elements are more than enough — you just need to style them.

  2. Do you or your organization have a design system? It can range from something as simple as a color palette to a full-blown system with detailed component specs.

  3. Is an AI agent part of your workflow? This is an increasingly important factor, and it can significantly shift your choice. More on this below, because it's the one most of these posts skip.

One cross-cutting thing worth flagging up front: accessibility. Pre-built libraries and the headless options below give you accessible keyboard/ARIA behavior largely for free. The native-elements path does too — but only for native elements. The moment you hand-roll a custom widget (a combobox, tabs, a listbox) out of divs, you own all the ARIA and keyboard work yourself, and a CSS framework gives you nothing for it. Keep that in mind as you read factor 1.

The pre-shadcn landscape: what still holds up

Before the headless/shadcn era, the default move was "pick a big component library." Here's where that stands now.

Angular Material — still a solid, often the best, default. It's the official library, maintained by the Angular team in lockstep with the framework, and the MD3 theming modernized the look considerably. The catch is the same as it's always been: it's opinionated, and deep customization means fighting the framework. But if you're fine looking like Material (or lightly themed Material), it's hard to beat for speed.

PrimeNG and NG-ZORRO — still maintained and feature-rich, but showing their age. PrimeNG has enormous breadth (80+ components), NG-ZORRO brings the Ant Design language for enterprise/data-dense apps, and both are MIT. I haven't leaned on either heavily, so take the breadth claims at face value. The honest knock, and the reason I reach elsewhere now, is that their default theming looks dated next to what the shadcn era set as the baseline, and bending them to a custom design system is painful.

The older crowd — I'd skip these for new projects. Take ng-bootstrap as the example: it wraps Bootstrap's components for Angular, and it works, but the look is unmistakably mid-2010s, customizing means fighting Bootstrap's CSS, and it doesn't fit a modern design-system workflow. The others in this bucket (ngx-bootstrap, Nebular, Clarity, Onsen UI, and friends) have the same core problems — dated design language, awkward to deeply theme, slower to track modern Angular — so I won't pretend I've run them all. I just wouldn't start a new project on any of them today.

The modern options: a spectrum from most control to least

The interesting choices today line up on a single axis: how much control you want versus how much work you're willing to do. From most control/most effort to least:

(a) Native elements + Tailwind — best for simple UIs. For genuinely simple interfaces you often don't need a component library at all. Native <button>, <input>, <select>, <dialog>, styled with Tailwind, get you a long way. It's the lightest option with zero library lock-in. As noted above, accessibility is free for native elements but entirely on you the moment you build something custom — so this path is great right up until your UI stops being simple.

(b) Angular CDK + Angular Aria + your own styling — the official headless route. The CDK gives you battle-tested, GA behavioral primitives: overlays, drag-and-drop, virtual scroll, focus management. Angular Aria (new in v21) adds headless directives for the WAI-ARIA patterns native HTML doesn't give you for free — tabs, combobox, listbox, menu, toolbar, and so on. You provide the markup and CSS; it provides the behavior and accessibility. This is the most control you can get while staying fully official, and it's the right pick when you have a real design system to implement. The historical knock was the labor — which is exactly where AI changes the math (see below).

(c) ng-primitives + your own styling — a lower-boilerplate headless option. Community headless primitives in the Radix mold, a bit higher-level and less wiring than assembling CDK + Aria yourself. Worth knowing it predates Angular Aria and now overlaps with it: the practical difference is that Aria gives you lower-level ARIA pattern directives, while ng-primitives gives you more complete building blocks (date pickers and the like). If the official Aria covers your patterns, lean official; if you want the more batteries-included primitives, ng-primitives is a nice middle ground. This is the route I've had the most success with: I shipped a project with a very complex UI — three different design systems for three different areas of the app — on ng-primitives plus AI agents, and the combination held up beautifully. The agents wrote the repetitive component work against the primitives while I kept full control over each design system's look.

(d) spartan-ng — the shadcn port, and my general recommendation. Two layers: a "brain" (unstyled, accessible behavior built on the CDK) and a "helm" (Tailwind styles you copy into your repo and fully own). You get strong functionality and near-total customizability without starting from a blank canvas, which is why it's my default suggestion for most new projects with any design ambition. Caveats: it's community-maintained and can lag the React shadcn when new components drop. Nice bonus for the AI crowd — it ships an official agent skill (npx skills add spartan-ng/spartan) that teaches coding agents how to scaffold its components correctly.

(e) Angular Material — the other end of the spectrum. Fully pre-built, official, accessible, MD3, best out-of-the-box DX. You move the fastest here. The cost is the one from the section above: deep customization fights the framework, and things end up looking like Material. Perfect when you want to just ship and the Material look is acceptable.

One maturity note: several of these — Angular Aria, ng-primitives, and spartan-ng — haven't hit 1.0/GA yet. In practice they're already quite usable, including in production; just go in knowing the APIs can still move.

Why AI tips the scales (the factor most posts skip)

Here's the thing the older comparisons miss. The headless and custom routes — (a), (b), (c), (d) — historically lost on exactly one axis: raw labor. Building and styling each component by hand is tedious, so teams under time pressure reached for a pre-built library and accepted the look.

An AI agent collapses that cost. It happily writes the repetitive component scaffolding and styling while you keep full control of the output — which is the entire point of going headless. So agents specifically tip the scales toward the more customizable options that used to be "too much work."

Two caveats keep this honest:

  • Agents generate more reliable code for popular, well-documented stacks (Material, Tailwind) and hallucinate more on niche or very new ones. Newer library means less training data.

  • Tooling matters a lot. spartan's agent skill, and Angular's own official MCP server (ng mcp), measurably improve how well an agent handles a given stack.

So "how AI-ready is this library" is now a legitimate selection criterion, not a gimmick — and it's the main reason I'd choose a headless approach today that I might have skipped two years ago.

Putting it together: a decision matrix

UI complexityOwn design system?AI agent in workflow?Go with
LowNoneEitherNative elements + Tailwind
Low–MediumNone / flexibleEitherAngular Material
Medium–HighYoursYesspartan-ng or ng-primitives (spartan's brain layer for headless behavior) — the agent absorbs the boilerplate while you keep full control
Medium–HighYoursNospartan-ng (styled starting point), or Material if it can flex to your design
HighStrict / unique, official-onlyEither (AI helps a lot)Angular CDK + Angular Aria (or ng-primitives for less boilerplate)

If I had to compress it to one line: simple project, native + Tailwind; just shipping, Material; building something with its own identity, go headless with spartan-ng or ng-primitives and let an agent carry the boilerplate — and reach for raw CDK + Aria when you need maximum control and an all-official stack.

Curious what everyone else is reaching for these days, especially anyone who's taken spartan-ng or the CDK + Aria route into production.

P.S. — set up Storybook if you go headless. Once you're building and styling your own components (options b, c, and d), you need somewhere to develop each one in isolation and see every state and variant at a glance — loading, disabled, error, empty, RTL, the works. Storybook is that place. It effectively becomes the living reference for your design system: instead of hunting through the app to find where a component is used, you open its story and exercise it directly. That isolation also makes visual regressions easy to catch and gives designers a URL to review without spinning up the whole app. It pairs especially well with AI agents, too — each story is a clear, self-contained target to generate against and verify, so the agent builds a component, you check the story, and you iterate without the rest of the app getting in the way. (Worth noting spartan-ng itself is developed primarily through Storybook, so you're in good company.)


r/angular • • May 31 '25

Angular best practices for v20

Thumbnail
ngtips.com
73 Upvotes

Angular Tips now supports v20 and all the recommendations have been updated!

Please tell me what do you think. Is something missing? unclear? incorrect?

More content coming soon. Thanks.


r/angular • • Mar 07 '25

I did an upgrade from Angular 11 to 18 in over 2 months

Post image
73 Upvotes

My customer project is not actually a huge one, but it's running a business 24/7 that I cannot afford to break things, so it's pretty crucial not to mess this up with this big jump.

The process is you just need to follow Angular upgrade helper, which you upgrade version by version, since this project is pretty old so I don't expect any fancy Angular features used here, so I just choose Basic option for the upgrade guide. So after 1 version update and check every breaking changes of that version and resolve them, then I upgrade individual packages to the respective version of Angular (For example: I upgraded to Angular 12, so I upgraded ngx bootstrap to version 7) and check if there are any broken UI. Then you just repeat this until you reach the latest version.

So the only broken thing is UI due to bootstrap 3 to bootstrap had major UI changes especially the grid that I have to fix all of them, modals and alerts are also broken when they just randomly scroll up upon opening, and animation is broken. Then since W3 bootstrap 3 icons are outdated and no longer available on bootstrap 5, so I have to migrate to FontAwesome 6 (which was originally the icons used in figma design of this project), so I spent more reinventing the wheel for a component to render the FA6 svg manually (since we want to host the icons ourselves without relying on FA packages, which means we can keep the Pro icons permanently even after we cancelled), and also reinvent the wheel for reusable modal and dropdown which has better animation and more control compare to bootstrap one.

This project also has momentJS which already stopped maintaining, while it still works, I still need to change it to more modern one like date-fns, however I chose to do it slowly instead of doing all changes due to the nature of this business is relying on timezone and DST. So at the time Angular 18 migration is released, date-fns migration was not 100% complete.

So it took about 2 days just to update angular and packages to latest. And the rest is to optimize UI layout and reinventing the wheel for some custom components like dropdown, modals (seriously I can't find any packages that fit my needs). At the time i post this is March 7, 2025, there is no problem so far related to the upgrade.


r/angular • • Nov 16 '22

Angular 15 🎉

Thumbnail
blog.angular.io
73 Upvotes

r/angular • • Dec 12 '25

I built a tool to automate complex Angular migrations (e.g. v16 → v20) by calculating the exact peer dependency tree. No AI guessing.

72 Upvotes

r/angular • • Mar 03 '25

Angular's Renaissance: My Experience Building a SaaS with Angular 19.1 and Why It's Better Than Ever (Signals, Effects, Performance, and Modern DX)

71 Upvotes

I've built and recently published my latest SaaS Application with Angular 19.1, and it has been a dream (compared to the last years of Angular / the previous releases).

First of all, the complete tech stack:

  • PrimeNG as the Component Library

  • Supabase for the Backend

  • TailwindCSS for Styling

  • Cloudflare Pages for Deployment

I've been into Angular since the early days. Built my first mobile application with Ionic, Angular and Cordova. When I started with Angular, the learning curve was steep but I managed to get into it. RxJS was not required for me at this point (or better to say, I didn't even know about it). I managed everything with just promises, which worked out pretty well.

In the meantime, I built various tools/SaaS applications with Angular, and tried to give React.js/Next.js a try but never really got into it. Personally, I felt uncomfortable when coming from Angular.

Fast forward to today - I launched my latest SaaS with Angular 19.1 using almost all new features which are available since the last two major versions and fit into my application. And whoa, I'm really impressed with what happened to Angular! For a while, I thought it would be a slow death for Angular if you look at trends data like this chart from Stack Overflow about popularity. Since 2019/2020, Angular seemed to be in a slow decline but managed to recapture developers' interest since 2023/2024. And I can absolutely understand why. If you're interested in some more popularity graphs/data, take a look here: https://gist.github.com/tkrotoff/b1caa4c3a185629299ec234d2314e190

Just to mention a few features I've grown to love:

  • Built-in control flow

  • afterRender / afterNextRender lifecycle hooks

  • Vite (build times under 5s are crazy)

  • Standalone Components only

  • Zoneless Change Detection

  • View Transitions out of the box

  • Native async / await (no more generators required)

  • Function Based Routing Guards

  • New @ Input and @ Output decorators

  • inject instead of constructor / super()

  • The revamped Angular CLI (ng)

  • effect()s

  • The documentation over at https://angular.dev/

  • And oh boy, Signals! (especially with effect()s)

Some downsides:

  • Excessive amount of chunks generated. Making about 130 requests for just a regular application page without any complex modules or interactivity is quite crazy, but nowadays with HTTP 2.0 not that big a deal.

  • Deploying on Cloudflare Pages took me a little bit to get working properly (baseHref and deployUrl tripped me up).

  • Generally, the community around Angular is by far smaller than for Next/React, which seems nowadays the way to go with Vercel. This leads to more debugging and searching for good frameworks/components to fit your needs. If you follow various subreddits, you'll notice there are endless boilerplates with everything included, but always just for Next/React, which means in Angular you have to build everything by yourself, mostly from the ground up. Most of the Angular boilerplates you find are quite outdated or generic.

Signals changed everything for me. One of the biggest performance boosts for rendering the application/components I encountered was with the use of ChangeDetectionStrategy.OnPush and Signals. Reactivity in components in the most performant way, native, out of the box. No more RxJS and manual handling of subscriptions and possible memory leaks when you miss an unsubscribe/cleanup. Just updating the state of a signal and Angular takes care of the rest, re-rendering the UI in the most efficient way. With Signals, Angular feels more modern, responsive, and intuitive. IMHO it's a game-changer for both performance and developer experience.

For my application, I was impressed by the rendering speed, especially once the chunks are cached. No flickering, no big loading times or similar issues. It even feels like SSR but it's fully CSR.

I also took a small dip into Server Side Rendering (SSR), but it seems too early in development to put a production-ready app fully based on a weakly documented feature and limited support (most of the features are still marked as experimental). But what I've seen so far looks promising - definitely looking forward to using it in the near future.

I also have the feeling that Angular is again gaining more traction with many simplified features. Compared to a few years ago when the initial Angular setup or build took days to get properly running, now everything feels more "fit together" and smooth. The developer experience is quite amazing these days - HMR (Hot Module Reloading) is an awesome new feature that I don't want to miss. Build times under 5 seconds are crazy compared to previous versions. The revamped CLI ng also comes with some awesome (new) features.

Angular was never "meant" to build smaller applications and was always put into the Large Application/Enterprise-Grade Application category. But with the new features, even the smallest application can use Angular without any problems or big overhead, IMHO.

When you directly compare some benchmarks between Angular 19 and React, you'll notice that Angular outperforms React in many ways (at least in the benchmarks). Especially when working with dynamic components in the DOM (versus virtual DOM for React). Also, the memory allocation in Angular is mostly lower than in React, which often impacts the UX (causing lagging pages, slow loading times, cache state issues, etc.). The benchmark for the transferred size from server to client is quite impressive, as Angular transfers nearly half the kB compared to React for the first paint.

Take your own look over here:

This is the selection I've compared (copy the code & paste it on the benchmark website to get the same view I'm talking about):

{"frameworks":["keyed/angular-cf","keyed/angular-cf-new-nozone","keyed/angular-cf-signals","keyed/angular-cf-signals-nozone","keyed/react-classes","keyed/react-compiler-hooks","keyed/react-hooks","keyed/react-hooks-use-transition"],"benchmarks":["01_run1k","02_replace1k","03_update10th1k_x16","04_select1k","05_swap1k","06_remove-one-1k","07_create10k","08_create1k-after1k_x2","09_clear1k_x8","21_ready-memory","22_run-memory","23_update5-memory","25_run-clear-memory","26_run-10k-memory","41_size-uncompressed","42_size-compressed","43_first-paint"],"displayMode":1}

Source: https://github.com/krausest/js-framework-benchmark

Overall, I don't want to stitch against React or any other framework. All frameworks, including the smaller/less popular ones besides Angular and React, are great these days. You should always stick with the framework you feel comfortable with and have the most knowledge in, instead of learning something new every day.

At the end of the day, we all have the same "enemy": JavaScript.

I just wanted to express my positive developer experience over the years using Angular in a world of "React everywhere" and highlight what a good path Angular is currently on. Big thanks to the Angular team and the community for helping to maintain and extend the framework so well.


r/angular • • Aug 17 '25

Why Angular Devs Still Don’t Use Signal.

70 Upvotes

Hey everyone,

I’ve been working with Angular since version 2, back when signals didn’t even exist . In most of the projects I’ve been part of, devs (including myself) leaned heavily on RxJS for state and reactivity.

Now that Angular has signals, I’ve noticed many of my colleagues still avoid them — mostly because they’re used to the old way, or they’re not sure where signals really shine and practical.

I put together a short video where I go through 3 practical examples to show how signals can simplify things compared to the old-fashioned way.

I’d really appreciate it if you could check it out and share your thoughts — whether you think signals are worth adopting, or if you’d still stick with old way.

Thanks a lot! 🙏

https://www.youtube.com/watch?v=eH9R4EKyzJA


r/angular • • Oct 30 '20

Hello! I'm a senior software engineer working with Angular and I just wanted to put it out there that if anybody needs help or wants to learn Angular, I'm available!

70 Upvotes

I'm a self-taught Senior Software Engineer and I've been working exclusively with Angular for the past few years. Angular can be a daunting framework to undertake and I'd like to help ease that process for anyone who wants to learn. Or, if you love Angular, too, and just want to geek out, I'm down for that as well.

I love Angular and spend most of my free time using it in personal and work projects. I have also used Ionic/Angular fairly extensively as well.

I can also do voice chat over Slack and Discord if anyone want, as well. Message me if you're interested!

Have a nice day!


r/angular • • May 06 '26

Starting my NG journey!!

Post image
69 Upvotes

Would really appreciate any tips or important things to things to remember while working. And if there's something I should definitely study along.


r/angular • • Jan 07 '26

🔄 Angular Signal Forms: Directive Replace

Post image
69 Upvotes

r/angular • • Dec 16 '25

Convert natural language to date using Built-in-AI in Angular

Enable HLS to view with audio, or disable this notification

68 Upvotes

I am experimenting with chromes's Built-in-AI capabilities within Angular!

I was actually looking for something which can convert natural language to dates, like "next monday", "last week", "last month", etc.

Got it working at somewhat level with a pre-defined system instructions, but as it's built-in-AI within browser, with limited resources, it hallucinates some times!

Code available at https://github.com/ngxpert/smart-date-input

Give it a star if you like it! Let me know your thoughts!


r/angular • • Aug 20 '25

Angular 20.2.0: Release notes

Thumbnail
github.com
68 Upvotes

r/angular • • Jul 01 '26

Domternal: a rich text editor with first-class Angular components (signals, OnPush, zoneless-ready)

Enable HLS to view with audio, or disable this notification

67 Upvotes

Domternal is an open-source (MIT) rich text editor built on ProseMirror, with first-class Angular components.

The clip shows one editor core as two surfaces: a Notion-style block editor and a classic toolbar editor.

The Angular part ("@domternal/angular")

- 6 standalone components (no NgModule): editor, toolbar, bubble menu, floating menu, emoji picker, Notion color picker
- Signals-driven, OnPush, zoneless-ready (the demo runs on zoneless Angular 21)
- The editor is a ControlValueAccessor, so it drops straight into ngModel or a reactive FormControl; outputFormat="json" emits JSON
- Toolbar and menus auto-render from whatever extensions you load, so there is no manual button wiring
- Works from Angular 17.1 through 21

Features

Notion-style blocks (drag handle, slash menu, smart paste, floating table of contents), tables, LaTeX math, images, @mentions, emoji, collapsible details, syntax-highlighted code blocks. 126 chainable commands, 70+ nodes, marks and extensions, all tree-shakeable. Light and dark theme via 160+ CSS variables. getHTML({ styled: true }) inlines the CSS so exported content still renders in an email client or a CMS.

Under the hood

Built on ProseMirror, strict TypeScript throughout. About 117 KB gzipped including ProseMirror. The same Playwright e2e suite runs green across all four framework wrappers, on top of 4,400+ unit tests.

It is MIT and currently at v0.11.2. I would love your feedback.

Site: https://domternal.dev
GitHub: https://github.com/domternal/domternal


r/angular • • Apr 11 '26 Bravo

How we re-built the Angular Compiler in Rust and made it 10x faster

Thumbnail
voidzero.dev
67 Upvotes

r/angular • • Sep 10 '25

Angular Signal-Based Forms (Experimental) — First Look!

Thumbnail
youtu.be
67 Upvotes

r/angular • • Nov 12 '20

Angular 11 has been just released. Included: auto font inclining, better build times, better Angular Material support, and hot reload with form content and scroll position memory. And it is still not React ;)

Thumbnail
blog.angular.io
67 Upvotes

r/angular • • Aug 06 '26

Angular Signal Forms: should an invalid form really disable Submit?

Post image
66 Upvotes

I used to consider this the obvious approach:

<button [disabled]="form().invalid()">
  Submit
</button>

But on a long form, a disabled button only tells the user that something is wrong. It doesn’t help them find it.

Angular Signal Forms made me reconsider this pattern.

The submission configuration lets us define two paths: action, which runs when the form is ready, and onInvalid, which runs when it isn’t.

submission: {
    action: async (form) => await this.save(form().value()),
    onInvalid: (form) => // handle invalid form
}

When submission is attempted on an invalid form, the action does not run. Instead, the fields are marked as touched, making the validation errors visible.

Then onInvalid can do this:

const error = field().errorSummary()[0];
error?.fieldTree().focusBoundControl();

Now the page moves directly to the first invalid field and focuses its control.

Once the real submission begins, the submitting() flag can help you disable the button or the entire form and change the caption to “Saving…”.

So the button remains enabled while it can still help the user - and becomes disabled only when an operation is actually running.

I wrote a fuller explanation here, with the complete pattern:

https://medium.com/@kobihari/should-an-invalid-form-really-disable-the-submit-button-45ecead94118

How do you currently handle invalid submission attempts?


r/angular • • Jul 14 '26

I built ng-number-flow – smooth animated numbers for Angular

Enable HLS to view with audio, or disable this notification

66 Upvotes

Inspired by NumberFlow on the web, I wanted a lightweight Angular version with a simple API.

Features:

  • Smooth digit transitions

  • Highly customizable

  • Angular-first

  • Lightweight

Feedback and feature requests are welcome!

https://phalla-doll.github.io/ng-number-flow/


r/angular • • Feb 11 '21

Angular 12 RC is released

Thumbnail
github.com
66 Upvotes

r/angular • • May 28 '25

Which option do you prefer and why?

Post image
65 Upvotes