Deep dive into what makes Vike special.

• Vike's architecture, enabling unprecedented flexibility and dependability.
• Vike's philosophy.

Architecture

Flexible by design

Vike's low-level hooks represent a flexible foundation. For example, the hooks onRenderHtml() and onRenderClient() allow you to fully control and integrate:

• Any UI framework (React, Vue, Solid, ...)
• Any data connection (REST, GraphQL, RPC, ...)
• Any rendering strategy (SSR, SSG, SPA, HTML-only, islands, ...)

For a quick start, we recommend using Vike extensions instead of directly using low-level hooks. For example, if you use vike-react or vike-vue then you get a quick start like Next.js and Nuxt. Later, if the need arises, you can eject vike-react/vike-vue for a custom React/Vue integration.

Another example is the renderPage() function which enables you to embed Vike into:

• Any server (Express.js, Hono, Fastify, ...)
• Any deployment (AWS, Cloudflare, Vercel, ...)

Alternatively, you can pre-render your pages and deploy your app to any static host.

Conservative or cutting-edge, your choice

Vike is essentially a core with extensions for automatic tool integratation. This architecture fosters a diverse ecosystem of Vike extensions:

• Stable extensions, focusing on supporting conservative stacks in a long-term fashion.
• Cutting-edge extensions, focusing on experimenting new approaches.

For example, we are experimenting with RSC (React Server Components) in a separate extension vike-react-rsc. This allows us to experiment without disrupting vike-react users. Both extensions can be maintained for the foreseeable future, which means you can adopt RSC whenever you want and only if you need it.

You have the choice:

• If you prefer stability, you can choose stable extensions.

  You get unparalleled stability: Vike in itself is an unopinionated and stable core while Vike extensions are thin layers of glue code that can be maintained for a very long time.

• If you have special requirements or if you want to explore new approaches you can choose cutting-edge extensions, eject extensions, write your own extensions, and/or build your own framework.

  You have full control over tool integration with unparalleled flexibility to build whatever you need.

Vike's architecture is a fundamentally more flexible and dependable foundation.

Grow progressively

Vike's flexibility allows you to adapt your stack to needs that evolve as you grow, in a progressive fashion:

• One page at a time: you can progressively migrate your stack on a page-by-page basis.

  For example, you can start with an SPA and later, if the need arises, you can add SSR progressively one page at a time.

  Most configurations can be set on page-by-page basis, see Vike's config inheritance.

• One architectural component at a time: you can switch architectural components independently of each other.

  For example, you can start with RPC and later, if the need arises, you can progressively switch to GraphQL.

  You can swap every major architectural component thanks to Vike's separation of concerns.

Progressive migrations enable you to migrate much faster, iteratively, and in parallel to building your product.

Future-proof

Vike's flexible core is unopinionated and open to JavaScript's rapidly evolving ecosystem. It's a stable foundation with lightweight and flexible Vike extensions quickly adapting to the tools and approaches of tomorrow.

Flexible and reliable, by prioritization

If you create a feature request and explain why it's blocking you, we will treat it with higher priority.

We quickly fix bugs, usually within 24 hours.

Vike's team is responsive and we provide a guideline on how to receive assistance from us.

Build your own framework

Vike enables you to build your own internal company framework, empowering your Software Architects to fully own the architecture while providing your Product Developers with a company framework for quickly experimenting, iterating, and shipping production-grade apps.

Your company framework can include everything that is needed to ship products (frontend, backend, data fetching, authentication, deployment, error tracking, analytics, ...) so that your Product Developers can focus on what they do best.

You can build your own internal ecosystem of tools. It's a powerful way to scale your teams. It also enables you to ensure that the same stack is being used throughout your company, fostering cross-domain contributions and sharing.

Philosophy

Separation of concerns

Vike is carefully designed with a clean separation of concerns, for unprecedented flexibility and dependability.

This enables you to choose architectural components independently of each other, and progressively switch them as you grow.

Flourishing do-one-thing-do-it-well ecosystem

Vike's separation of concerns enables architectural components to be developed independently of each other.

A vibrant ecosystem of do-one-thing-do-it-well tools competing with each other is one of the cornerstones of JavaScript's success.

Other frameworks tightly couple architectural components together, which is a fundamental and structural hindrance that prevents innovation.

For example, Vike doesn't have built-in RPC (aka Server Actions). This flexibility enables RPC approaches to be developed and innovated independently of Vike.

Listening to users

We engage in constructive conversations with users. While we enjoy pushing the envelope and innovating, our priority is, first and foremost, to listen and solve real-world needs of users.

Vike's Open Source Pricing means that your success directly translates into our success. (Whereas other frameworks that make money from selling other products are inclined to have skewed priorities.)

Passionate leadership

Vike is an independent project 100% led by engineers with a long-term vision.

Thanks to Vike's Open Source Pricing we don't serve the interests of any unrelated business: we only serve the interests of users.

We are passionate about technology and strive for an increasingly collaborative society.