NestJS

React Native brings React's declarative UI framework to iOS and Android. With React Native, you use native UI controls and have full access to the native platform.

• Declarative. React makes it painless to create interactive UIs. Declarative views make your code more predictable and easier to debug.
• Component-Based. Build encapsulated components that manage their state, then compose them to make complex UIs.
• Developer Velocity. See local changes in seconds. Changes to JavaScript code can be live reloaded without rebuilding the native app.
• Portability. Reuse code across iOS, Android, and other platforms.

https://reactnative.dev/

Angular is a development platform, built on TypeScript. As a platform, Angular includes:

• A component-based framework for building scalable web applications
• A collection of well-integrated libraries that cover a wide variety of features, including routing, forms management, client-server communication, and more
• A suite of developer tools to help you develop, build, test, and update your code

With Angular, you're taking advantage of a platform that can scale from single-developer projects to enterprise-level applications. Angular is designed to make updating as straightforward as possible, so take advantage of the latest developments with a minimum of effort. Best of all, the Angular ecosystem consists of a diverse group of over 1.7 million developers, library authors, and content creators.

https://angular.io/guide/what-is-angular

Blazor is a framework for building interactive client-side web UI with .NET:

• Create rich interactive UIs using C# instead of JavaScript.
• Share server-side and client-side app logic written in .NET.
• Render the UI as HTML and CSS for wide browser support, including mobile browsers.
• Integrate with modern hosting platforms, such as Docker.
• Build hybrid desktop and mobile apps with .NET and Blazor.

https://dotnet.microsoft.com/en-us/apps/aspnet/web-apps/blazor

Flutter is Google’s portable UI toolkit for crafting beautiful, natively compiled applications for mobile, web, and desktop from a single codebase. Flutter works with existing code, is used by developers and organizations around the world, and is free and open source.

Flutter is designed to support mobile apps that run on both Android and iOS, as well as interactive apps that you want to run on your web pages or on the desktop. (Desktop support for Windows is now available on the stable channel; support for macOS and Linux is in beta, but a snapshot of the beta is also available on the stable channel.)

Apps that need to deliver highly branded designs are particularly well suited for Flutter. However, you can also create pixel-perfect experiences that match the Android and iOS design languages with Flutter.

Flutter’s package ecosystem supports a wide variety of hardware (such as camera, GPS, network, and storage) and services (such as payments, cloud storage, authentication, and ads).

Flutter is different than most other options for building mobile apps because it doesn’t rely on web browser technology nor the set of widgets that ship with each device. Instead, Flutter uses its own high-performance rendering engine to draw widgets.

In addition, Flutter is different because it only has a thin layer of C/C++ code. Flutter implements most of its system (compositing, gestures, animation, framework, widgets, etc) in Dart (a modern, concise, object-oriented language) that developers can easily approach read, change, replace, or remove. This gives developers tremendous control over the system, as well as significantly lowers the bar to approachability for the majority of the system.

https://flutter.dev/

Rails is a web application development framework written in the Ruby programming language. It is designed to make programming web applications easier by making assumptions about what every developer needs to get started. It allows you to write less code while accomplishing more than many other languages and frameworks. Experienced Rails developers also report that it makes web application development more fun.

Rails is opinionated software. It makes the assumption that there is a "best" way to do things, and it's designed to encourage that way - and in some cases to discourage alternatives. If you learn "The Rails Way" you'll probably discover a tremendous increase in productivity. If you persist in bringing old habits from other languages to your Rails development, and trying to use patterns you learned elsewhere, you may have a less happy experience.

The Rails philosophy includes two major guiding principles:

• Don't Repeat Yourself: DRY is a principle of software development which states that "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system". By not writing the same information over and over again, our code is more maintainable, more extensible, and less buggy.
• Convention Over Configuration: Rails has opinions about the best way to do many things in a web application, and defaults to this set of conventions, rather than require that you specify minutiae through endless configuration files.

https://rubyonrails.org/

React is a JavaScript library for building user interfaces.

Declarative - React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes. Declarative views make your code more predictable and easier to debug.

Component-Based - Build encapsulated components that manage their own state, then compose them to make complex UIs. Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM.

Learn Once, Write Anywhere - React doesn’t make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code. React can also render on the server using Node and power mobile apps using React Native.

https://reactjs.org/

Svelte is a tool for building fast web applications.

It is similar to JavaScript frameworks such as React and Vue, which share a goal of making it easy to build slick interactive user interfaces.

But there's a crucial difference: Svelte converts your app into ideal JavaScript at build time, rather than interpreting your application code at run time. This means you don't pay the performance cost of the framework's abstractions, and you don't incur a penalty when your app first loads.

You can build your entire app with Svelte, or you can add it incrementally to an existing codebase. You can also ship components as standalone packages that work anywhere, without the overhead of a dependency on a conventional framework.

https://svelte.dev/

Symfony is an Open Source distributed PHP framework. 

Symfony is an internationally recognized, stable development environment. An innovative and easy-to-use work environment thanks to integrating solutions created in other environments such as dependency injection (taken from Java) and specifically developed solutions such as the Web Debug Toolbar or the Web Profiler. Finally, by adopting *de facto* standards, Symfony does not confine you to its environment, but allows you to choose the software components that you want to use.

https://symfony.com/

Vue (pronounced /vjuː/, like view) is a JavaScript framework for building user interfaces. It builds on top of standard HTML, CSS and JavaScript, and provides a declarative and component-based programming model that helps you efficiently develop user interfaces, be it simple or complex.

https://vuejs.org/

WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable compilation target for programming languages, enabling deployment on the web for client and server applications.

Efficient and fast - The Wasm stack machine is designed to be encoded in a size- and load-time-efficient binary format. WebAssembly aims to execute at native speed by taking advantage of common hardware capabilities available on a wide range of platforms.

Safe - WebAssembly describes a memory-safe, sandboxed execution environment that may even be implemented inside existing JavaScript virtual machines. When embedded in the web, WebAssembly will enforce the same-origin and permissions security policies of the browser.

Open and debuggable - WebAssembly is designed to be pretty-printed in a textual format for debugging, testing, experimenting, optimizing, learning, teaching, and writing programs by hand. The textual format will be used when viewing the source of Wasm modules on the web.

Part of the open web platform - WebAssembly is designed to maintain the versionless, feature-tested, and backwards-compatible nature of the web. WebAssembly modules will be able to call into and out of the JavaScript context and access browser functionality through the same Web APIs accessible from JavaScript. WebAssembly also supports non-web embeddings.

https://webassembly.org/

Astro is an all-in-one web framework for building fast, content-focused websites. Astro leverages server-side rendering as much as possible to significantly reduce the amount of JavaScript sent to the browser, resulting in high performance websites. Astro is also fully-featured yet flexible, containing features like file-based routing, asset handling, image optimisation, and full TypeScript support.

One of Astro's main features is that it's UI-agnostic, meaning you can use any frontend framework. There is official support for React, Preact, Solid, Svelte, Vue and Lit, as well as Astro's own component language, and you can even mix and match different frameworks on the same page.

Astro reached v1.0 in August 2022 after 16 months of development and testing.

https://astro.build

Material UI is an open-source component library, built for React projects and based on Google's Material Design system. It consists of a comprehensive set of components, ranging from primitive components such as buttons, layout components such as a grid system, and more complex interactions such as tooltips and modals. By default, Material UI is styled to match Material Design as much as possible, but applying custom themes is fully supported.

Material UI was originally its own sole product, but has since become part of a wider suite of products called MUI. Other variations of Material UI are available from MUI, such as a core "unstyled" version called MUI Base.

NextJS is a React framework that allows you to create server-side rendering and static web applications. NextJS includes all the extra opinions that make starting a new project so confusing such as automatic code splitting, Babel and TypeScript support, and error handling.

We love it because of the ease of getting started, and the ability to fall into good practice like starting with continuous integration. It's also trivial to migrate off Vercel (the default hosting environment) if you have specific needs.

The site you are looking at was built using NextJS.

PostCSS is a tool for transforming CSS using JavaScript. It has been gaining traction in recent years over more traditional CSS pre-processors such as SCSS and Less, and actually gets used in pipelines along with these frequently for things like auto-prefixing vendor-specific CSS properties.

Perhaps more significantly, PostCSS represents a way to use tomorrow's CSS today without necessarily having to use one of the heavyweight preprocessors featured on this list. New, experimental syntaxes for nesting or modern colour definitions such can be transpiled back to CSS that can be understood by whatever target set of browsers you choose, allowing developers to make use of new tools without impacting the user experience.

Most significantly, the PostCSS ecosystem has grown to make it a true competitor to SCSS, whilst remaining closer to the CSS spec in terms of how modern featured like variabled (CSS Custom Properties) are handled.

RedwoodJS is a full-stack framework focused on bringing a Minimum Viable Product to fruition as quickly as possible. It does this through a powerful command-line tools: for example, with one command a developer can create a new web page complete with a database schema, CRUD operations and a framework for unit testing.

It also has a big focus on the developer experience, and so eliminates as much boilerplate as possible thorugh the use of the CLI.

RedwoodJS uses:

• React on the front-end
• GraphQL as the database
• Prisma as an ORM
• Jest and Storybook for testing
• There is an option to use TypeScript throughout the project

https://redwoodjs.com/

SolidJS is a reactive user interface library in a similar vein to React, Vue etc which aims to offer simple, performant reactive UIs. Much like other UI libraries, it comes with its own set of conventions for how reactivity gets set up with data but, broadly speaking, the principles are pretty similar to what you would expect to find from any of the major players in this space. In fact, if you have developed with React Hooks before, Solid's way of doing things should feel both familiar and simpler.

Why Accellerate?

Solid's focus on performance have it consistently at the very tippy-top of the UI library performance chart (both on the client side and on the server side), lagging only very slightly behind vanilla JS in the browser. It also has enough about its API that feels familiar to React developers to make the transition easy, whilst removing much of what can make React feel complex. We expect to see Solid's use on the rise in the coming years, as more developers realise the benefits of the switch.

Tailwind CSS is a utility-first CSS framework which aims to allow its users to create complex UIs without needing to leave their HTML. It does this through use of single-use utility classes that each do one thing - like mx-0 to set the horizontal margin of an element to 0, or text-green to make the text colour green (or whatever is set with the name green in the project options).

Vite offers a modern approach to frontend tooling, offering instant start and rapid loading of changes by sending native ES modules to the browser where supported rather than rebundling and waiting for that work to complete before reloading the UI.

Vite has spawned an ecosystem of plugins for handling the most popular JS libraries, as well as testing and other areas of tooling. It is blazing fast and reliable, and should be a solid consideration when starting any new project.

Web Components comprises a set of technologies that allow developers to create custom elements with encapsulated functionality and reuse them in their web apps. Think of Web Components as an analogue to React components, but utilising the native web platform APIs rather than React's own APIs.

Broadly speaking, the Web Components spec includes three main technologies – Custom Elements, the Shadow DOM and HTML Templates. Combining these together will allow a developer to create an entirely standalone custom element that can be used in any web application, and can even be orchestrated by custom view libraries such as React and Vue.

There are libraries around that aim to simplify the process of creating web components such as Stencil and Lit. These libraries aim to address some of the issues with native web compoenents such as clunky data binding, but keep bundle size small and still leverage as much of the native web platform as possible.

Why Grow?

We see the value in interoperability between different view libraries, and leveraging the web platform. The ability to have a component library written once and usable in any web project, regardless of framework or view layer, is a huge win for both efficiency and uniformity. Controlling brand styles between projects using one component library makes brand management easier and cheaper, too.