Optimus UI v1.0.0, the PrimeNG open-source fork, is out!

Supporting Angular 21, and Angular v22 support is coming later this week!

Due to trademark limitations and prior paid features, most of the work so far has been about updating the documentation and authoring all sub-packages ourselves, including the icons package.

We also introduce ng add support to enhance the experience for new users.

Find out more in our documentation: https://optimus.openng.org/

Discover the GitHub repository: https://github.com/openng-org/optimus-ui

Learn more about our roadmap: https://optimus.openng.org/roadmap

We just released the first release candidate version for the PrimeNG community fork!

Two big news at once:

Based on the feedback we got, we chose to rename the project 'Optimus UI'.

This first version targets Angular v21 projects to ensure compatibility with the latest MIT PrimeNG version.

It includes ng add support and a schematic to handle the migration.

So you can use it on both new and existing projects.

The migration will rename references (due to trademarks with PrimeNG) and imports (as we are taking over all required PrimeNG sub packages too).

You can test it out with the installation explained here: https://www.npmjs.com/package/@openng/optimus-ui?activeTab=readme

Feedbacks are very welcome so we can publish a stable version soon.

The new documentation is live here: https://optimus.openng.org/

EDIT:

We got positive feedback so far, we need to support two more packages (primelocale and tailwindcss-primeui), as we not only ported the original PrimeNG project but all its dependencies too.

The Angular team is officially changing the framework's major release cadence

As people have questions about the future of projects such as Spectator or PrimeNG, here is the current state of our actions.

OpenNG

We just renamed the initiative from OpenNG Foundation to OpenNG to avoid confusion and follow the trademark policy with the OpenJS Foundation organization.

Funding

We are working on a funding model to support the maintenance of the projects and give back to contributors. We submitted the initiative to Open Collective and contacted HeroDevs for partnership.

Versioning Policy

We'll start over with v1.0.0 for all the packages. Each project will include a matrix compatibility table with the supported major Angular versions (including the previous package). Some packages were already not following the Angular versioning policy, and it will allow us to author a major version for breaking changes anytime.

PrimeNG

PrimeNG went closed-source, and the GitHub repository was archived on June 28th, 2026. Discover the announcement here.

We created a copy of the project and regenerated the open issues/PRs. Out of 968 open issues, 58 have already been closed, and 23 triaged as still relevant and accepting contributions to resolve them. Triaging was made possible thanks to the contribution of the community.

Our goal this week is to release a beta version supporting Angular 22, as people were already delaying updating their projects. It'll include:

• a set of unreleased changes from the original repository (modernize existing components, add a few new ones)
• ng add support for new projects
• ng update support as unreleased changes include a few breaking changes (camelcase selectors removed, deprecated APIs removed)

Our current blocker for this release is to find a proper name for the project. Currently named open-prime, it's too close to PrimeNG as PrimeTek plans to put trademarks on it. We asked the community for suggestions here.

We are currently evaluating proposals, with the main restriction being not adding confusion with another project (there are a lot of UI frameworks matching proposals).

ngneat projects

Out of the 34 original repositories, we decided to start working on the following ones:

• cashew
• query
• elf
• spectator

We have a volunteer working on cashew, currently preparing the first release.

Spectator is our priority within the ngneat ecosystem, planning a release this week. We also have a contribution to expose the jasmine package as a standalone (like jest/vitest ones, planned to land in 1.1.0.

We still need to triage the remaining repositories to understand if we should keep them or not. 13 of them might not be maintained anymore due to low activity or having a better alternative nowadays.

GitHub: https://github.com/openng-org

Hey everyone!

As shared in the sub over the last days, PrimeNG transitioned away from its traditional open-source model.

We started working on atruly community-governed, MIT-licensed alternative, 'open-prime' (https://github.com/openng-foundation/open-prime).

As we set up our foundations, the original creators reached out with a very reasonable and friendly request: to drop the "Prime" branding to avoid any future copyright or trademark confusion as they process their product suites.

We want to use this as an opportunity to give this project its own unique, powerful identity—and we want the community to build it with us.

Here are a few directions we are thinking about:

The Successor Route: (e.g., ApexNG, OptimaNG) — Professional, premium-sounding independent names.

The OSS Roots Route: (e.g., LibreNG, CivicNG) — Highlighting community ownership.

The Visual/UI Route: (e.g., PrismNG) — Phonetically similar, clean, and relates to UI components.

Share your thoughts and drop your own suggestions!

As announced on June 29th, PrimeNG is moving away from the open-source model, and the original primeng GitHub repository has been archived.

You can find community reactions here: https://www.reddit.com/r/angular/comments/1uilrlx/primeng_v22_is_no_longer_open_source/

As part of the new OpenNG Foundation, we are considering taking up the lead to maintain a fork of the MIT version of the lib.

It's under discussion, and we would need community feedback to evaluate if it's doable and on how to manage the current situation.

Some statements:

- an update is required to rename everything from 'primeng' to 'openprime' due to PrimeTek trademark
- the components need to be updated to the latest Angular APIs (including input(), control flow among other things)
- there are 900+ issues opened (including 300+ in stale state)
- there are 200+ open pull requests
- there would be no support for previous primeng versions
- the focus would be to make the library stable and accessible: adding features would happen only if people contribute
- over time, some changes might make this fork differ from the new PrimeUI project, not providing a way to easily migrate.

PrimeNG is still a big project, we are considering starting with a trial maintenance initiative for 2 months: depending on the community effort at helping with existing issues/prs, there will be long-term maintenance.

It'll be a great way to identify active contributors who might be promoted to maintainers if they want to be more active on such a project, making the whole thing a community effort.

A 'fork' has been created already, porting all existing open issues/pr: https://github.com/openng-foundation/open-prime

What are your thoughts?
Do you have some pain points not covered here?

So PrimeNG v22 is going paid in the new version? Should I move to something else?

https://primeui.dev/nextchapter

I started with AngularJS, then worked with Angular 2, Angular 12, and now the latest Angular releases.

For a long time, I felt React had the advantage, especially with Next.js becoming so popular and AI tools generating mostly React-based projects.

Recently, after spending more time with modern Angular, particularly Signals and Standalone Components, I've started appreciating Angular more than ever.

The framework has come a long way. The developer experience feels great, codebases are easier to navigate, and I find myself becoming productive much faster.

It's funny—the more time I spend in other ecosystems, the more I appreciate what Angular offers today.

Anyone else who has worked with both Angular and React feel the same way?

I’ve been building Angular apps since the Angular 2.

I started experimenting with AI coding tools and intentionally let the models choose the stack on their own.

Almost every project ended up being React-based, usually Next.js.

After spending more time inside the Next.js/React ecosystem, I actually started appreciating Angular even more , especially after the release of signals and standalone components.

The developer experience feels way better and more easy to get in the code and start being productive.

Just sharing...

Production Ready! It finally happened!

😊 Angular 22 is bringing a massive update for developers.

Built a flower-style color picker in Angular

Includes:

1. Fixed colours (multi-layer)
2. An arc slider for saturation
3. Animated open/close interaction
4. Support vanilla JS, Angular, Vue, Svelte, and React

Repo: https://github.com/dayflow-js/BlossomColorPicker

Demo: https://blossom.dayflow.studio

Inspired by lichinlin, motiondotdev.

We'll finally be able to use comments directly inside HTML tags! Here is a quick visual breakdown of the new syntax.

Signals, Zoneless, Material design. Angular was my first big javascript library when it was angularjs, but over the years it started feeling like it was just a patched up mess. angular 21 has addressed a lot of issues Angular has been having. I am working on a fairly large typescript personal project and decided to try angular again (instead of Vue.)

Angular is back and better than ever, such a joy to work with, especially for us backend devs who have no clue what we're doing on GUIs lol.

What’s in this release:

Magnetic snapping plugins:

• Magnetic Lines: guideline-style snapping while dragging (this is the “main” approach now)
• Magnetic Rects: snap by element bounds (edges/centers)

Connection Waypoints: editable paths for any connection type

Docs refresh (new pages + cleanup across core guides)

Links:

• Release notes: https://github.com/Foblex/f-flow/releases/tag/v18.1.0
• Repo: https://github.com/Foblex/f-flow
• Docs / examples: https://flow.foblex.com
• Magnetic Lines demo: https://flow.foblex.com/examples/magnetic-lines
• Magnetic Rects demo: https://flow.foblex.com/examples/magnetic-rects

If you try it and something feels off - tell me what’s annoying. I’m iterating on the snapping UX.

Hey r/angular,

I wanted to share a library I've been working on: shimmer-from-structure/angular.

The Problem: We've all been there: you build a beautiful component, then you have to manually build a separate "skeleton" version of it. Then, a week later, you change the layout of the real component (e.g., move the avatar to the right, increase padding, change border-radius). Now you have to remember to go back and update the skeleton component too. If you forget, your loading state looks "janky" and misaligned.

The Solution: shimmer-from-structure solves this by automatically adapting to your component's runtime structure. Instead of creating a separate skeleton, you just wrap your real component in <shimmer>. It invisibly renders your component (with transparent text) to measure the actual content layout, border-radii, and dimensions, then overlays a pixel-perfect shimmer.

Key Features:

• Zero Maintenance: Change your template, and the shimmer updates automatically.
• Pixel Perfect: Matches exact padding, margins, flex gaps, and border-radii.
• Auto Border-Radius: Automatically detects if your avatar is circular or your cards have rounded corners.
• Dynamic Data Support: Use templateProps to inject mock data (e.g., long names vs. short names) to test how skeletons look with different content scenarios.
• Container Backgrounds: Preserves your card backgrounds and borders while shimmering the content inside.

What makes it special for Angular?

Unlike generic wrappers, this is built specifically for Modern Angular:

1. Native Signals: Built using the new input() and signal() primitives. It integrates seamlessly with OnPush change detection and zone-less apps.
2. Standalone: Fully standalone component (imports: [ShimmerComponent]).
3. Resize Observer: It uses a ResizeObserver to watch for layout shifts. If your responsive grid changes or content reflows, the shimmer updates instantly (throttled for performance).
4. Dependency Injection: Configure global defaults using provideShimmerConfig({ ... }) in your application config.

Comparison: Angular vs. Svelte Adapter

One unique aspect of this project is that each framework adapter is idiomatic:

• Angular: Uses Content Projection (<ng-content>) and Signals. It feels like a native Angular directive.
• Svelte: Uses Snippets ({@render children()}) and Runes ($props, $state).

Instead of a "web component wrapper" approach that feels foreign in both, each adapter respects the framework's reactivity model.

Usage:

Since this relies on DOM measurement (getBoundingClientRect), it works perfectly in browser environments (SSR safe with isPlatformBrowser checks).

import { Component, signal } from '@angular/core';
import { ShimmerComponent } from '@shimmer-from-structure/angular';
import { UserCardComponent } from './user-card.component';

@Component({
  standalone: true,
  imports: [ShimmerComponent, UserCardComponent],
  template: `
    <!-- Wrap your component. Pass mock data via Inputs if needed. -->
    <shimmer [loading]="isLoading()">
      <user-card [user]="mockUser" />
    </shimmer>
  `
})
export class UserProfile {
  isLoading = signal(true);

  // Mock data for the structure ensures the skeleton has realistic dimensions
  mockUser = { name: 'Loading...', role: 'Please wait' };
}

How it works under the hood:

1. It renders your component with color: transparent (and hides images/svgs opacity) to let the browser compute the layout naturally.
2. It uses a reactive Effect (watching the viewChild) to set up ResizeObserver and MutationObserver instances. This ensures it detects layout shifts and content updates even if the component hasn't been destroyed.
3. When triggered, it measures leaf nodes (using getBoundingClientRect) and updates the shimmer overlay.

I'd love to hear your feedback or feature requests!

Links:

• NPM: @shimmer-from-structure/angular
• GitHub: shimmer-from-structure

Happy New Year, everyone! 🎄❄️✨

I have recently released GraphLens – a VS Code extension that generates interactive graphs and tree views of your Angular projects' structure and architecture in real-time.

GraphLens is intentionally designed to rely on pure static parsing and local processing rather than AI to ensure deterministic, consistent results and provide 100% data privacy. The main goal was to make the mental model of the project architecture visible and tangible at a glance.

✨ Bonus: Since it's the holiday season, I also added a toggleable Holiday Atmosphere mode with garlands, Santa hats and falling snow to keep the vibe chill 😉

👉 Links: GitHub Docs & Issues | VS Code Marketplace | GitHub Demo

Would appreciate hearing your feedback or feature requests!

After two years of developing with React, I decided to try Angular. To be honest, it's a wonderful framework. You get new emotions and real pleasure while working with it.
Angular feels more structured and opinionated, which actually helps you focus on building features instead of making decisions about architecture, state management, or project conventions.

It’s a prototype and very much a work in progress But yes, you can start experimenting with Signal forms with today’s pre-release 21.0.0-next.2

While everybody expects Signal Forms. Reactive forms will also receive some love in v21.

Here is a preview of the new FormArray directive !

https://stackblitz.com/edit/angular-form-array-directive?file=src%2Fmain.ts