What’s Missing From the Web Platform?

The web platform has seen remarkable advancements in recent years, with a proliferation of powerful new APIs across JavaScript, CSS, and browser runtimes. These innovations have empowered developers to build richer, more dynamic applications than ever before. Yet, as with any evolving ecosystem, there remain critical areas where the web platform could significantly improve, offering developers more native, performant, and accessible tools. This exploration delves into the collective wishlist of capabilities that would elevate the web from 'great' to 'exceptional,' examining everything from fundamental UI primitives to advanced AI integration.

The Evolving Landscape of Web Primitives

One of the most persistent challenges for web developers lies in the limitations of existing HTML form controls and UI elements. While browsers provide basic inputs like text fields, checkboxes, radio buttons, and date pickers, these often lack the flexibility for custom styling and advanced functionality that modern applications demand. This deficiency frequently leads developers to bypass native elements entirely, reaching for external JavaScript libraries to achieve desired aesthetics and behaviors. The discussion highlights a crucial insight: current native primitives, such as the input type='date', often deliver a subpar user experience and offer limited styling control.

A significant step forward is the customizable select element, which empowers developers to style dropdowns fully while retaining essential accessibility and keyboard navigation benefits. This approach, akin to 'headless UI' where the browser provides functionality and the developer supplies the visual components, offers a glimpse into a more flexible future. Expanding on this, the community eagerly anticipates robust native support for multi-select and combo box elements, enabling rich filtering and selection experiences without heavy JavaScript dependencies. Organizations like Open UI are actively researching and proposing these vital UI elements, underscoring the platform's commitment to improvement.

However, not all UI components are destined for native implementation. Complex elements like advanced date pickers, which require intricate features such as range selection, event marking, or conditional availability, may remain the domain of external libraries. The philosophy here shifts: provide simple, stylable primitives that can be composed or enhanced by libraries, rather than attempting to solve every complex use case natively. Similarly, tabs are seen as a long-overdue addition, as current HTML elements like accordion or details do not offer the desired native tab functionality. The poor default styling of file upload inputs, coupled with the need for immediate image previews, also calls for a more capable and stylable native solution.

The widespread use of custom toggle switches, often built by hiding native checkboxes and styling divs or spans, creates significant accessibility challenges. The fact that Safari already offers native toggles as an option demonstrates that this is a feasible and much-needed primitive across all browsers. Scott emphasized the necessity for new browser primitives to be inherently stylable, stating, "nothing should be added that can't be stylable anymore." This principle ensures that developers maintain design control without sacrificing native functionality or accessibility.

Another point of contention is native drag and drop. While the web platform provides draggable and droppable attributes and associated JavaScript events, the default user experience, particularly the visual feedback and item management during a drag operation, often falls short. Wes points out the inherent complexity of drag and drop interactions, where decisions like whether an item should be ghosted, immediately removed from a list, or copied upon dropping vary greatly by application. This complexity often necessitates sophisticated external libraries, such as Atlassian's pragmatic drag and drop, suggesting that core primitives might suffice, leaving intricate logic to specialized solutions.

Advancing JavaScript Syntax and APIs

The evolution of JavaScript itself is another critical area. The desire for type annotations within native JavaScript is strong, effectively integrating TypeScript's benefits directly into the language. There are proposals, such as types as comments, which would allow TypeScript syntax in the browser, with the browser simply ignoring it. This approach aims to leverage TypeScript's ubiquity, which Scott noted has become practically synonymous with modern JavaScript development. While this would be a significant shift, the cautious approach by standards bodies, avoiding a rush to integrate a specific type system, is understandable, learning from past experiences like the jQuery era.

The pipe operator is another highly anticipated syntax feature. This operator would streamline function chaining, allowing the output of one function to be seamlessly piped as input to the next. Currently, developers often resort to nested function calls, leading to a 'blooming onion' structure that hinders readability and comprehension. A native pipe operator would drastically improve code clarity, making data transformations more intuitive and easier to follow.

Beyond syntax, new APIs are crucial. The navigator.getBattery API, which allows web applications to detect battery status and optimize performance accordingly, exemplifies how native features can enhance user experience. Riverside's use of this API to prompt users to plug in their laptops for better video performance showcases its practical value.

However, some API needs are far more pressing. A standardized cookie consent API is paramount. The current landscape of cookie banners is a usability and accessibility nightmare, often featuring dark patterns and inconsistent behavior. A native API could standardize the consent process, integrating with browser-level preferences, thereby improving privacy controls and user experience across the web. The efforts of companies like Sentry, which has significantly reduced its reliance on tracking cookies, highlight the complexity developers face in navigating current regulations.

An integrated identity API could revolutionize authentication. Most users are already logged into their browsers or operating systems. Leveraging this state, perhaps through passkeys or biometrics like Face ID, to streamline logins across web applications would eliminate the constant reinvention of authentication mechanisms, though this raises complex security and privacy considerations.

For DOM manipulation, a getElementByText() API is a long-sought feature. While elements can be selected by ID, class, attributes, or even child elements, direct selection based on inner text is not natively supported. Such an API would greatly benefit automation, testing, and agentic browser interactions, harkening back to capabilities found in XPath.

Native reactive templates represent another significant desire, enabling direct, declarative updates to the DOM when data changes. Whether through signals or other reactive primitives, this would eliminate much of the manual DOM manipulation and reconciliation currently handled by JavaScript frameworks. Scott shared how he often creates a custom rerender string in vanilla JavaScript to emulate this behavior, underlining the widespread need for a native solution.

Regarding data management, the web platform lacks robust native databases that don't rely solely on IndexedDB or the limited localStorage. The desire for something akin to PostgreSQL in WebAssembly suggests a need for more powerful and developer-friendly local data persistence. Similarly, a sync protocol leveraging CRDTs (Conflict-free Replicated Data Types) would simplify building collaborative, local-first applications.

Improving virtualization is also critical for performance in long lists. Current JavaScript-based virtualization libraries often break essential browser features like Command+F search, as off-screen elements are not rendered. While content-visibility in CSS aims to address this, its current implementations have shown inconsistent performance. The ideal scenario is for browsers to intelligently manage rendering large data sets without requiring explicit developer intervention or compromising core functionality.

For web forms, extending the supported HTTP verbs beyond GET and POST to include PUT, PATCH, and DELETE would align web standards with modern RESTful API design. This change would enable richer, progressively enhanced form submissions without JavaScript hacks.

Finally, text metrics capable of providing bounding box information for individual characters would greatly assist in advanced text layout and animation, particularly when combined with newer CSS properties like textbox-trim that address common text alignment issues.

Lower-Level Connections and Browser Diversity

Accessing lower-level hardware via browser APIs could unlock a new class of web applications. Bluetooth and Web Serial APIs, which allow web pages to communicate directly with devices over Bluetooth or USB, are incredibly useful for tasks like programming microcontrollers or updating device firmware. The current lack of widespread browser support, particularly from Safari and Firefox, limits their utility. Similarly, direct socket access, NFC, and RFID capabilities would transform Progressive Web Apps (PWAs` into powerful tools for interacting with the physical world, enabling use cases like scanning tags directly from a web page.

On the CSS front, adding the ability to specify animation speed (e.g., pixels per second) rather than just duration would provide more consistent and physically intuitive motion design. The concept of CSS strict mode is also appealing, offering a way to opt out of CSS's historical quirks and baggage, much like JavaScript's use strict directive or ES modules do for JavaScript. This would allow developers to enforce modern best practices, such as border-box sizing by default, in a more predictable environment.

The perennial debate over browser engines highlights the critical importance of diversity. While some developers express a desire for all browsers, especially Safari on iOS, to adopt the Chromium engine for consistency and ease of debugging, this uniformity would be detrimental to the web's long-term health. A single engine would stifle innovation, create monopolies, and lead to stagnation, underscoring the necessity of competition between engines like WebKit, Blink, and Gecko.

The Future: AI Integration and Beyond

The most forward-looking frontier is native AI access within the browser. While early implementations, such as Chrome's beta for local AI models, are still rudimentary and slow, the potential is immense. The vision is for an API that allows web applications to leverage local, private AI models baked into the user's device, or to load custom models, or even connect to external APIs. This would democratize AI capabilities, making inference fast, private, and free (in terms of direct cost to the developer).

Such integration would transform common web interactions. Imagine a date picker that understands natural language inputs like "February 18th three years ago" or "the last 40 days starting next Tuesday." Or input fields that can intelligently parse and validate complex data like Canadian postal codes or credit card expiration dates, adapting to varied user inputs. Scott emphasized that those who dismiss AI's current capabilities are missing a fundamental shift in the development landscape.

Finally, the desire for high-quality Web Speech API in server-side runtimes like Node, Bun, and Deno points to a broader need for robust, performant speech-to-text and text-to-speech capabilities. The current browser implementations often fall short in quality, making external models like 11 Labs or Alibaba's Qwen TTS more attractive. Integrating these powerful models, perhaps with the option to leverage local device models, would greatly enhance accessibility and interactive experiences, moving beyond robotic voices to more natural and personalized audio.

Looking Ahead

The web platform is a dynamic and ever-evolving entity. While tremendous progress has been made, the collective wishlist for better UI primitives, enhanced JavaScript syntax, powerful new APIs, and native AI capabilities reveals a clear path for future development. The patient, methodical approach of standards bodies, balancing innovation with backwards compatibility and long-term health, ensures that the web continues to grow as a robust and versatile application platform. As developers, continuing to voice these needs and experiment with new possibilities will undoubtedly shape the web of tomorrow.