Making Web Components Work: A Framework's Perspective

The Browser and Web Platform developer room at FOSDEM 2026 hosted an intriguing presentation that challenged prevailing assumptions about Web Components and their relationship with modern frontend frameworks. Hayleigh Thompson's talk, "Making Web Components work: a framework's perspective," explored how the Lustre framework for the functional programming language Gleam is quietly revolutionizing the way we think about component architecture on the web.

Web Components have indeed become a contentious topic in web development circles over the past decade. Platform advocates champion them as a solution to interoperability challenges, arguing that they can simplify tooling and distribution while providing a common foundation for experimentation and innovation. The promise is compelling: a standardized way to create reusable components that work across different frameworks and libraries without the need for complex build tools or runtime adapters.

However, this optimistic view has been met with considerable resistance from framework authors and developers who find Web Components problematic in practice. The most common complaints center around the complexity they introduce at runtime, requiring special-case handling in framework code, and the argument that Custom Elements represent the wrong level of abstraction for modern component systems. Many developers find themselves caught between the theoretical benefits of platform-native components and the practical realities of building applications with their preferred frameworks.

Thompson's presentation offered a refreshing counterpoint to this debate by showcasing how Lustre, a frontend framework for the functional programming language Gleam, has embraced Web Components as a fundamental building block of its runtime architecture. This approach represents a significant departure from the conventional wisdom that has dominated frontend development for years.

The key insight from Lustre's implementation is that Web Components can work effectively when frameworks adopt a different conceptual model of what "components" should be. Rather than treating Web Components as an add-on or special case, Lustre has integrated them deeply into its core architecture, leveraging their strengths while mitigating their weaknesses through thoughtful design choices.

This approach offers several potential benefits for framework users. First, it provides a path toward greater interoperability between different frameworks and libraries. By building on a common platform primitive, components could theoretically be shared and reused across different parts of the web ecosystem without the need for complex adapters or translation layers. This could significantly reduce the fragmentation that currently exists in frontend development.

Second, the Lustre approach could simplify tooling and distribution. Since Web Components are natively supported by browsers, there's no need for complex build processes or runtime dependencies to make components work. This could lead to smaller bundle sizes, faster load times, and a more streamlined development experience.

Third, by using Web Components as a core building block, frameworks like Lustre can focus on providing higher-level abstractions and developer experience improvements rather than reinventing the wheel when it comes to component management. This allows framework authors to concentrate on what makes their approach unique while leveraging the solid foundation provided by the platform.

The implications of this approach extend beyond just Lustre and Gleam. If successful, it could inspire other framework authors to reconsider their relationship with Web Components and explore new ways of integrating platform primitives into their architectures. This could lead to a more unified web development ecosystem where components can flow freely between different tools and frameworks.

However, the talk also acknowledged the challenges that remain. The current state of Web Components still has limitations, particularly around styling encapsulation, state management, and the developer experience compared to more mature framework-specific solutions. The success of approaches like Lustre's will depend on continued improvements to the Web Components specification and browser implementations.

Thompson's presentation at FOSDEM 2026 represents an important contribution to the ongoing conversation about the future of web development. By demonstrating a practical, working example of how Web Components can be effectively integrated into a modern framework, Lustre provides a compelling case study that challenges us to rethink our assumptions about the relationship between frameworks and platform primitives.

The video recording of this talk, available in both AV1/WebM and MP4 formats, along with subtitle files, provides valuable insights for anyone interested in the evolution of web component architecture. As the web continues to evolve, approaches like Lustre's may well point the way toward a more interoperable and unified future for frontend development.

The broader significance of this work extends to the fundamental question of how we build for the web. Should frameworks continue to reinvent component systems from scratch, or is there value in building on the solid foundation provided by platform primitives? Lustre's approach suggests that the answer may lie somewhere in between – leveraging the strengths of Web Components while providing the abstractions and developer experience that modern applications require.

As the web development community continues to grapple with questions of interoperability, performance, and developer experience, presentations like Thompson's offer valuable perspectives on how we might move forward. The success of approaches like Lustre's could ultimately determine whether Web Components fulfill their promise as a unifying force in web development or remain a niche technology used primarily by platform advocates.

The FOSDEM 2026 talk serves as a reminder that innovation in web development often comes from unexpected places. By combining the functional programming paradigm of Gleam with a reimagined approach to Web Components, Lustre demonstrates that there are still unexplored territories in the landscape of frontend architecture. As frameworks continue to evolve, the lessons learned from projects like Lustre will likely influence the direction of web development for years to come.

For developers interested in exploring this approach further, the Lustre project and Gleam language provide concrete examples of how these ideas can be implemented in practice. The ongoing development of Web Components and related specifications will also play a crucial role in determining whether this vision of a more unified web development ecosystem can become a reality.