Deep dive into what makes Vike special.

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

Architecture

Flexible by design

Vike is designed from the ground up to be both flexible and stable.

For example, Vike's low-level 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 or Nuxt. Later, if the need arises, you can eject vike-react/vike-vue for a completely custom React/Vue integration.

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

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

For a quick start, you can use vike-server instead of manually integrating renderPage().

Instead of using a server, you can also pre-render your pages and deploy to any static host.

Conservative or cutting-edge, your choice

Vike is essentially a core with extensions for automatic tool integration. 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 — and only if — you want.

You have the choice:

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

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

• If you have special requirements or 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 provides a flexible and dependable foundation.

Grow progressively

Vike's flexibility allows you to progressively adapt your stack to evolving needs:

• 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 progressively add SSR 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.

  With Vike, you can swap every major architectural component.

Progressive migrations enable you to migrate a lot 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 that can quickly adapt 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 treat it with higher priority.

We quickly fix bugs, usually within 24 hours.

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

Build your own framework

Vike enables you to build a company internal framework, empowering your Software Architects to fully own the architecture and empowering your Product Developers with a full-fledged company framework to quickly experiment, iterate, and ship production-grade apps.

Your company framework can include everything (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 while ensuring that the same stack is 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, which is a 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 top priority is, first and foremost, to listen and address the real-world needs of our 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 naturally inclined to have skewed priorities.)

Passionate leadership

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

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.