Introduction

In recent years, frontend development has undergone a rapid

transformation, with a growing number of frameworks emerging to
address the increasing complexity of web applications. From single-page
applications to progressive web apps, developers are now faced with a
wide array of tools and frameworks designed to streamline UI
development, improve performance, and enhance user experience.
Among the most prominent frameworks are React, developed by Meta,
Vue, created by Evan You (initially under Google’s support), and Svelte,
designed by Rich Harris and later supported by Vercel. These frameworks
have established large communities and gained wide industry adoption
thanks to their innovation and flexibility.
Beyond these mainstream solutions, a new wave of frameworks such as
SolidJS ,Qwik, Astro, and Lit are gaining traction. These emerging
frameworks push the boundaries of performance and developer
experience, introducing novel paradigms like partial hydration,
resumability, and compilation-based rendering. While not all of them are
backed by large corporations, some—like Qwik and Astro—are
developed and maintained by innovative teams and open-source
communities with growing industry support.
This paper aims to provide a comparative analysis of these frameworks
based on three essential criteria: performance, learning curve, and
community support. Additionally, it explores future trends in frontend
development, including emerging technologies and shifting industry
paradigms.
By examining the strengths and trade-offs of these frameworks, this
research seeks to guide developers, teams, and organizations in making
informed decisions when selecting a frontend toolset.
 Research Objectives
This research aims to achieve the following objectives:
1. To compare the most popular and emerging frontend frameworks
including React, Vue, Svelte, and newer tools such as SolidJS, Qwik,
Astro, and Lit—based on three essential criteria:
- Performance
- Learning curve
- Community support
2. To evaluate the practical strengths and limitations of each framework
in the context of different development needs (e.g., enterprise-scale
apps, static sites, beginner projects).
3. To identify emerging trends and future directions in frontend
development, with a focus on performance optimization techniques,
innovative rendering paradigms, and architectural shifts.
4. To provide a structured decision-making guide that helps developers
and organizations choose the most appropriate framework for their
specific technical and organizational requirements.
5. To assist technical leads and decision-makers in selecting the best
framework that aligns with their team’s expertise, project scalability
needs, and long-term maintenance goals.
1. Comparative Overview of Modern Frontend Frameworks

1.1 React: Origins, Features, Strengths, and Limitations

React is an open-source JavaScript library for building user interfaces,
primarily for single-page applications (SPAs). It was developed by Jordan
Walke, a software engineer at Facebook, and was first released in 2013.
React was originally created to solve issues related to dynamic and high-
performing UIs on platforms like Facebook’s news feed and Instagram.
How React Works
React introduces the concept of a Virtual DOM, which allows it to
efficiently update and render components by only re-rendering the parts
of the UI that have changed. Components are the building blocks of
React applications, written using JSX — a syntax extension that looks like
HTML but compiles to JavaScript.
React promotes a unidirectional data flow, where data is passed from
parent to child components via props. It does not impose a specific
architecture, but it often works alongside tools like Redux (for state
management) and React Router (for navigation).
Key Advantages
- Massive ecosystem: Rich collection of libraries and tools (Next.js,
React Native, Redux).
- Reusable components: Facilitates modular code and maintainability.
- Large community: Extensive documentation, tutorials, and hiring
opportunities.
- Flexibility: Can be used for web, mobile (React Native), and hybrid
apps.
Key Limitations
- Learning curve: Concepts like JSX, hooks, lifecycle methods, and state
management may confuse beginners.
- Boilerplate: Requires combining multiple tools (e.g., Redux, routing,
forms) which increases complexity.
- Rapid evolution: APIs and best practices change frequently, requiring
constant learning.
Ideal Use Cases
React is best suited for:
- Large-scale, interactive web applications
- Enterprise dashboards and platforms
- Applications needing SSR (via Next.js)
- Cross-platform mobile apps (via React Native)

1.2 Vue: Origins, Features, Strengths, and Limitations

Vue.js is a progressive JavaScript framework for building user interfaces
and single-page applications. It was created by Evan You, a former
Google engineer, and released in February 2014. Vue was designed as a
lightweight alternative to AngularJS, combining the best ideas from
React and Angular in a simpler, more approachable format.
How Vue Works
Vue uses a declarative rendering system based on an HTML-based
template syntax, which allows developers to bind data to the DOM using
directives such as `v-bind` and `v-model`. Vue’s core library focuses solely
on the view layer, and it can be integrated incrementally into existing
projects.
Vue features reactive two-way data binding (like Angular) and
component-based architecture** (like React), making it highly adaptable.
Single File Components (SFCs) in `.vue` files allow for encapsulating
HTML, JavaScript, and CSS in a single file.
Key Advantages
- Gentle learning curve: Its template syntax is similar to HTML, making it
accessible to beginners.
- Clear documentation: Vue is praised for having some of the best official
documentation among frontend frameworks.
- Flexibility : Can be used for both small interactive components or full-
scale SPAs.
- Built-in features : Tools like Vue Router and Vuex are officially
maintained and tightly integrated.
Key Limitations
- Weaker corporate backing : Compared to React (Meta) or Angular
(Google), Vue relies heavily on the open-source community.
- Fragmentation : Vue 2 and Vue 3 introduced breaking changes, causing
some division in the ecosystem.
- Job market : Fewer job opportunities compared to React, especially
outside of Asia.
Ideal Use Cases
Vue is particularly well-suited for:
- Projects requiring fast onboarding and rapid prototyping
- Teams with junior or non-JavaScript-heavy developers
- Mid-sized business apps or admin dashboards
- Regions where Vue adoption is high (e.g., China, parts of Europe)
1.3 Svelte: Origins, Features, Strengths, and Limitations
Svelte is a component-based JavaScript framework created by Rich
Harris (then at The Guardian) and first released in November 2016. In
2020 the project moved under Vercel’s stewardship, accelerating its
ecosystem growth. Svelte’s defining idea is to shift work from the
browser to the build step, producing highly‐optimized vanilla JavaScript
with no runtime framework payload.
How Svelte Works
Instead of using a virtual DOM, Svelte is a compiler : at build time it
converts `.svelte` files (which combine markup, logic, and styles) into
imperative DOM operations. State changes are tracked via reactive
declarations that trigger finely-grained updates.
Key Advantages
- Zero runtime overhead : Small bundles and faster initial load since no
framework code ships to the client.
- Straightforward syntax : Templates look like HTML; reactivity uses
simple assignment (`count += 1`).
- Built-in state management : Stores and reactive statements reduce the
need for external libraries.
- Excellent DX : Hot-module reloading, concise APIs, and first-class
TypeScript support via SvelteKit.
Key Limitations
- Smaller ecosystem : Fewer third-party components and libraries
compared with React/Vue.
- Breaking changes across major versions : Migration from v2 → v3
broke APIs; future compiler shifts may repeat this.
- SSR complexity without SvelteKit : For server-side rendering and
routing, teams almost always rely on SvelteKit, which is still evolving
rapidly.
- Tooling expectations : Because Svelte is compiler-centric, some
conventional React/Vue tooling paradigms don’t transfer directly.
Ideal Use Cases
Svelte excels in:
- Performance-sensitive web apps where bundle size and runtime speed
are critical
- Small-to-medium single-page apps or widgets that need quick
prototyping
- Projects with teams that value a simple, HTML-like authoring
experience
- Edge-deployed, SSR-friendly apps using SvelteKit for routing and
endpoints
1.4 SolidJS: Origins, Features, Strengths, and Limitations
SolidJS is a declarative JavaScript library for building user interfaces,
created by Ryan Carniato and first released in 2018. While it shares
conceptual similarities with React in terms of component structure and
JSX usage, SolidJS takes a radically different approach to rendering and
reactivity.
It abandons the virtual DOM entirely, favoring a fine-grained reactivity
system inspired by reactive programming (similar to KnockoutJS and
MobX), which enables extremely fast updates to the DOM.
How SolidJS Works
SolidJS uses compile-time optimizations and reactive primitives like
`createSignal()` and `createEffect()` to track dependencies and update
the DOM directly and surgically. It compiles the reactivity graph during
build time, resulting in highly performant output without needing diffing
or reconciliation algorithms.
Like React, Solid uses JSX syntax but with a different underlying model—
components are functions that return actual DOM nodes instead of
virtual representations.
Key Advantages
Top-tier performance: Outperforms many frameworks in benchmarks
due to fine-grained DOM updates.
No virtual DOM overhead : Eliminates the need for reconciliation,
reducing CPU usage.
Predictable reactivity model : Makes state handling clear and powerful.
Small bundle size : Great for fast-loading apps.
Key Limitations
Steeper learning curve : Developers must learn reactive primitives and a
new mental model.
Smaller community and ecosystem : Fewer integrations and third-party
libraries compared to React or Vue.
Less documentation : While improving, still not as extensive as older
frameworks.
SSR still evolving : SolidStart (the official SSR framework) is relatively
new.
Ideal Use Cases
SolidJS is ideal for:
Developers building high-performance, reactive UIs
Applications where rendering speed and resource efficiency are critical
Projects where fine-grained control over updates is needed
Teams willing to adopt a newer, less conventional framework
3.5 Qwik: Origins, Features, Strengths, and Limitations

1.5 Qwik is a cutting-edge JavaScript framework designed for ultra-fast

web applications. It was created by Misko Hevery , the original creator of
Angular, and released in its early versions by the team at Builder.io in
2021.
Qwik introduces a new paradigm called resumability , which aims to
solve one of the biggest bottlenecks in web performance: long hydration
times in traditional single-page applications.
How Qwik Works
Most frameworks use hydration to “re-activate” server-rendered content
on the client side. Qwik bypasses this by enabling applications to resume
execution from the server without needing to rehydrate the full app. This
results in faster initial load and interaction times, especially on low-end
devices or poor networks.
Qwik achieves this by splitting the application into small lazy-loadable
chunks, known as “symbols.” Only the code relevant to user interaction is
loaded when needed.
It uses JSX for templating and has an associated meta-framework called
Qwik City for routing and server-side rendering.
Key Advantages
Ultra-fast loading : Optimized for initial page load and Time to Interactive
(TTI).
Resumability : No need to rehydrate the full page—app logic resumes
instantly.
Component-level lazy loading**: Ensures only needed parts of the app
are loaded on demand.
Ideal for SEO : Pre-rendered content is immediately available to crawlers.
Key Limitations
New and evolving: Still in early stages of adoption with a smaller
ecosystem.
Complex mental model : Concepts like resumability and symbol-based
loading may be unfamiliar.
Limited documentation and tooling : Improving steadily, but not yet at
the level of React or Vue.
Fewer real-world implementations : Compared to more mature
frameworks.
Ideal Use Cases
Qwik is best suited for:
- Content-heavy websites requiring fast first-load performance
- Low-end devices or constrained bandwidth environments
- Applications where SEO and interactivity are both critical
- Teams experimenting with cutting-edge web performance technologies
1.6 Astro: Origins, Features, Strengths, and Limitations
Astro is a modern static site generator and frontend framework designed
to optimize performance and reduce JavaScript delivery. It was initially
released in 2021 by Fred K. Schott and the team at The Astro Technology
Company.
Astro was built with the philosophy of "ship less JavaScript," targeting
content-heavy websites like blogs, documentation sites, and marketing
pages.

How Astro Works

Astro allows developers to build components using various frontend
frameworks—including React , Vue , Svelte , and SolidJS —within a
single project. This interoperability is made possible through a powerful
plugin system.
The key innovation in Astro is its use of partial hydration, where
components are rendered on the server by default and only hydrated on
the client when necessary. Developers can control hydration behavior
using directives like `client:load`, `client:idle`, or `client:visible`.
Astro also supports MDX, Markdown, and TypeScript out of the box,
making it especially friendly for static content generation.
Key Advantages
Minimal JavaScript by default : Leads to blazing-fast page loads.
Multi-framework support : Developers can mix and match React, Vue,
Svelte, etc.
Great for SEO : Server-rendered HTML is immediately crawlable.
Simple setup : Excellent developer experience and easy configuration.
Ideal for static content : Integrates well with CMSs and Markdown.
Key Limitations
Not ideal for dynamic SPAs : While possible, Astro is optimized for static
content, not complex interactivity.
Still maturing : Some features (e.g., full SSR, authentication patterns)
require additional setup.
Limited plugin ecosystem : Compared to more established frameworks.
Ideal Use Cases
Astro is best suited for:
- Blogs, documentation sites, and landing pages
- Marketing websites with strong SEO requirements
- Projects that combine content and interactivity selectively
- Teams seeking a balance between performance and framework
flexibility
1.7 Lit: Origins, Features, Strengths, and Limitations
Lit is a lightweight, fast, and standards-based library for building web
components. It was developed by *Google* and released as LitElement
in 2018, later evolving into Lit 2.0 in 2021 under the umbrella of the
Polymer Project.
Lit focuses on delivering highly efficient, encapsulated UI components
using native Web Components standards, making it framework-agnostic
and highly reusable across different frontend stacks.
How Lit Works
Lit allows developers to create custom elements using standard Web
Components APIs like `customElements.define()` and the Shadow DOM.
It enhances native APIs by offering a simplified, declarative way to
manage rendering and reactivity.
The core idea in Lit is using template literals and a reactivity system
based on JavaScript getters and setters. It tracks updates automatically
and applies them efficiently to the DOM, without needing a virtual DOM.
Lit’s `.ts` or `.js` files define components with clear, class-based syntax,
making it easy to understand and adopt in standards-based projects.
Key Advantages
Standards-compliant : Fully based on Web Components, ensuring wide
compatibility.
Lightweight: Extremely small runtime (~5 KB), ideal for performance-
critical use.
Framework-agnostic : Can be used within any framework (React, Vue,
Angular, or vanilla JS).
Encapsulation: Shadow DOM ensures style and behavior isolation.
Enterprise-friendly: Well-suited for design systems and large-scale UI
libraries.

Key Limitations
Less beginner-friendly: Class-based syntax and low-level concepts may
confuse new developers.
Limited ecosystem : Fewer ready-made components or plugins compared
to React or Vue.
Lacks high-level abstractions : Offers less guidance or structure than full
frameworks.
Requires modern browser support : Older browsers may need polyfills
for Web Components.
Ideal Use Cases
Lit is best suited for:
- Building design systems or shared UI libraries
- Enterprise applications that use multiple frameworks
- Teams seeking high modularity and reusability
- Projects where adherence to web standards is critical
1.8 Framework Suitability by Developer Type and Project Context
Each framework tends to serve specific use cases and developer profiles.
*React* is often chosen for large-scale applications requiring high
flexibility and mature ecosystems.
Vue : is preferred in small-to-medium projects for its simplicity and ease
of integration.
Svelte and SolidJS : are attracting startups and performance-focused
teams due to their fast rendering and compact output.
Astro is ideal for content-heavy static websites such as blogs and
documentation.
Qwik : is designed for ultra-fast loading experiences, especially on low-
end devices or poor networks.
Lit : is widely used in design systems and enterprise apps that rely on
Web Components.
1.9 Ecosystem and Tooling Compatibility
Modern frameworks integrate with a variety of tools and standards:
- All major frameworks support TypeScript, modern build tools (like Vite
or Webpack), and SSR/SSG capabilities.
- React and Vue offer rich official ecosystems (Next.js, Nuxt), while
Svelte, Astro, and Qwik focus on cutting-edge developer experience and
minimalism.
- Lit integrates deeply with Web Components standards, making it
suitable for framework-agnostic architectures.
These differences play a significant role in framework selection based on
project size, performance goals, and developer workflow preferences.

1.10 Adoption and Popularity

The popularity of frontend frameworks is a key indicator of their
reliability, community size, and long-term viability. Based on GitHub
stars, npm downloads, and industry surveys like the State of JS, React
continues to dominate the frontend ecosystem with over 210K stars and
millions of downloads per week. Its widespread adoption by major
companies such as Facebook, Instagram, and Netflix reinforces its
industry relevance.
Vue maintains strong popularity, especially in Asia and among individual
developers and small businesses. It has over 210K GitHub stars,
comparable to React, and is used by companies like Alibaba, Xiaomi, and
Laravel.
Svelte, while newer, is gaining traction rapidly due to its simplicity and
performance. It consistently ranks among the most loved frameworks in
developer surveys and has over 70K GitHub stars.
Emerging frameworks like SolidJS , Astro , and Qwik are still growing but
show promising adoption trends. Astro, for example, is increasingly used
in documentation websites and static content projects due to its
performance-first design and flexibility with multiple frameworks.

These popularity trends reflect not only current usage but also future
potential and community momentum.
1.11 Learning Curve and Onboarding
The learning curve of a frontend framework significantly impacts how
quickly developers—especially beginners—can become productive.
React, while highly flexible and powerful, requires a solid understanding
of JavaScript fundamentals, JSX syntax, and concepts like hooks, state
management, and component lifecycles. Its minimalistic core and
reliance on external libraries can be overwhelming for newcomers, but
its vast ecosystem and resources help bridge the gap.
Vue is widely praised for its gentle learning curve. With clear
documentation, a template-based syntax similar to HTML, and integrated
state management, Vue is beginner-friendly yet powerful enough for
complex applications. It strikes a balance between simplicity and
scalability, making it ideal for both novices and experienced developers.
Svelte simplifies the onboarding process by removing the need for
complex abstractions like virtual DOM or build-time configuration. Its
syntax is close to vanilla HTML, CSS, and JavaScript, which lowers the
barrier to entry. However, understanding its compiler-based model and
reactive declarations may require a conceptual shift.
SolidJS , Qwik , and Astro introduce advanced performance concepts like
fine-grained reactivity, resumability, and partial hydration. While these
ideas offer technical benefits, they may pose a steeper learning curve,
particularly for developers unfamiliar with compiler-based frameworks
or SSR-heavy architectures.
Ultimately, frameworks that prioritize developer experience (DX) and
provide strong documentation—like Vue and Astro—tend to offer the
smoothest onboarding.

1.12 Developer Sentiment and Survey Results

Recent developer surveys such as the [State of JavaScript

2023](https://stateofjs.com) reveal significant insights about the
perception and adoption of frontend frameworks.
React continues to lead in global usage, particularly in large-scale
applications and enterprise environments. However, developer
satisfaction has slightly declined due to its increasing complexity and
reliance on third-party libraries.
Vue maintains a strong position, especially in Asia, praised for its
balanced architecture and approachable syntax. It consistently ranks high
in satisfaction and is widely adopted by small-to-medium businesses.
Svelte, SolidJS , and Astro stand out in terms of developer satisfaction,
frequently ranking at the top of "most loved" frameworks. Their
simplicity, performance, and developer experience (DX) are the main
contributors to their rising popularity.
Qwik , although relatively new, shows promising results due to its
innovative resumability model. It appeals particularly to performance-
critical applications.
Lit remains a niche choice, commonly used in design systems and
projects relying on Web Components standards , backed by Google.
These survey results validate the shifting preferences of modern
developers toward lightweight, performant, and developer-friendly
frameworks, reinforcing the analytical observations discussed in this
paper.
1.13 Performance Benchmarking
Independent benchmarks such as the [JS Framework Benchmark] offer
objective performance evaluations of frontend frameworks under
standardized conditions. These benchmarks typically assess operations
like table creation, row updates, and memory usage.

According to the 2023 benchmark results, SolidJS and Svelte consistently

rank at the top in terms of runtime performance, thanks to their fine-
grained reactivity and compilation-based rendering. These frameworks
generate minimal overhead and provide near-native speed in DOM
updates.
React, while performant with proper optimization (e.g., memoization,
lazy loading), tends to be less efficient in update-heavy scenarios due to
its virtual DOM diffing mechanism.
Qwik and Astro operate on different paradigms—resumability and partial
hydration, respectively—which make traditional client-side performance
comparisons less straightforward. Their strengths lie in initial load time,
bundle size, and server-side rendering efficiency .

1.14 Accessibility and SEO Considerations

As frontend frameworks evolve, considerations for web accessibility

(a11y) and search engine optimization (SEO) become increasingly vital,
especially for enterprise and content-driven applications.
Frameworks like React and Vue offer mature tools and best practices for
accessibility, including ARIA support, semantic HTML guidance, and
compatibility with screen readers. Their SSR companions (Next.js, Nuxt)
enhance SEO capabilities by allowing pre-rendering and dynamic
metadata injection.
Astro and Qwik are particularly well-suited for SEO-sensitive projects.
Their server-rendered or static-first architectures ensure that HTML is
available immediately to search engine crawlers, improving indexability
and load performance.
While Svelte, SolidJS, and Lit offer customizable rendering models,
developers must pay closer attention to accessibility semantics and use
additional SSR tooling (e.g., SvelteKit, SolidStart) to match the SEO
performance of Astro or Next.js.

Ultimately, accessibility and SEO support depend not only on the

framework itself but also on how developers implement and configure
their applications.

2. Future Trends in Frontend Development

As web applications continue to grow in complexity and user
expectations rise, frontend development is rapidly adapting through new
design paradigms, tooling improvements, and architectural shifts. The
following trends are shaping the next generation of frontend frameworks
and developer experiences:
1. Resumability and Server-Centric Architectures
Frameworks like **Qwik** are pioneering resumability—a model
where applications are sent as a serialized state from the server and
resume instantly on the client without rehydration. This reduces
JavaScript execution on the client, leading to faster initial load times.
2. Partial and Selective Hydration
Techniques used by Astro and others allow only essential components
to be hydrated on the client, keeping performance high and JavaScript
payloads low. This trend favors better SEO, accessibility, and resource
usage.
3. Compiler-First Design
Tools like Svelte and SolidJS continue to push the boundary by
compiling components at build time into optimized JavaScript, removing
the need for a runtime and boosting efficiency.
4. Edge Rendering and Streaming
Serverless edge computing (e.g., via Vercel, Cloudflare Workers) is
making it possible to stream UI updates from servers closer to users. This
enables real-time interactivity and improves perceived performance for
global audiences.
5. Framework Interoperability
Projects like Astro and Micro-Frontend architectures show a growing
desire to use multiple frameworks in the same app. This promotes
flexibility and lets teams adopt tools best suited to each feature or
module.
6. Enhanced Developer Experience (DX)
Frameworks are investing heavily in improving DX through better error
handling, hot reloading, zero-config setups (e.g., Vite-based ecosystems),
and integrated devtools. This makes modern frameworks more
accessible and productive, even for less experienced developers.
As these trends continue, future frontend development will likely be
characterized by hybrid architectures, high performance with minimal
JavaScript, and tools that prioritize developer productivity and user-
centric design.
3. Comparative Summary of Framework Strengths and Weaknesses
The following table summarizes key characteristics across frameworks to
support quick decision-making.
4. Practical Recommendations for Choosing a Frontend Framework

Choosing the right frontend framework depends on several factors

including the developer’s experience level, the project type,
performance needs, and the long-term maintainability of the application.
The following recommendations serve as a practical guide:
- For beginners or solo developers:
Start with Vue or Svelte. Both offer gentle learning curves, excellent
documentation, and fast setup, making them ideal for small projects or
personal learning.
- For developers seeking career opportunities in large companies**:
Focus on React, which remains the most in-demand framework in the
job market and is widely used in enterprise environments.
- For performance-critical applications (e.g., real-time dashboards, low-
bandwidth environments):
Consider SolidJS, Svelte, or Qwik, as they offer cutting-edge
performance through compiler-first or resumability models.
- For static content-heavy websites (blogs, documentation, landing
pages):
Astro is the best fit, offering excellent SEO performance, partial
hydration, and support for multiple frameworks.
- For building design systems or framework-agnostic UI libraries:
Use Lit, which is built on Web Components standards and works well
across different frontend stacks.
- For full-stack developers or teams prioritizing SSR and edge rendering
 Look into Next.js (with React) or SvelteKit (with Svelte), which provide
complete server-side rendering ecosystems with modern deployment
support.

Ultimately, the “best” framework is the one that aligns with the project’s
technical needs, the team’s familiarity, and the product’s scalability
requirements.

Conclusion

The frontend development ecosystem continues to evolve at a

remarkable pace, driven by the need for better performance, improved
developer experience, and scalable architecture. This paper compared a
wide range of frontend frameworks—both established and emerging—
based on their performance, learning curve, and community support.
React and Vue remain dominant choices with mature ecosystems and
large communities. Meanwhile, newer frameworks like Svelte, SolidJS,
Qwik, and Astro offer innovative models that challenge traditional
paradigms and provide compelling benefits for specific use cases.
In addition to technical analysis, this research explored future trends
such as resumability, partial hydration, compiler-first approaches, and
edge rendering—trends that will shape the next generation of frontend
applications.
By combining analytical comparison with practical guidance, the study
provides a roadmap for developers and organizations to choose the right
framework based on their goals, expertise, and project constraints.
Ultimately, the diversity of modern tools reflects the diversity of needs—
and the best choice is one that aligns with both current priorities and
future scalability.
 References
1. Grigore, A., & Luca, C. (2020). A Comparative Study of Front-End
Frameworks. *Informatica Economică*, 24(2), 19–28.
https://doi.org/10.24818/issn14531305/24.2.2020.02

2. The State of JavaScript (2023). *Annual Developer Survey*.

https://stateofjs.com/en-us/

3. Meta Open Source. (2023). *React Official Documentation*.

https://reactjs.org/

4. Google. (2023). *Lit Framework Documentation*. https://lit.dev/

5. GitHub Trends (2023). *Stars and Contributions for Frontend

Repositories*. https://github.com/trending
‫وزارة التعليم العالي والبحث العلمي‬
‫األكاديمية الليبية للدراسات العليا ‪-‬‬
‫الخمس‬
‫مدرسة العلوم االساسية ‪ -‬قسم علوم‬
‫الحاسوب‬

‫‪Trends in Frontend Frameworks: React, Vue, Svelte, and Beyond‬‬

‫احمد ابوزيد ابوعمود‬ ‫اعداد الطالب ‪:‬‬