h2oai/wave
Wave
Wave est un framework d'application web full-stack et une bibliothèque d'UI low-code conçue pour construire des tableaux de bord de données en temps réel et des interfaces interactives en utilisant Python et R. Il permet aux développeurs de définir des interfaces utilisateur basées sur navigateur et de gérer l'état côté serveur sans écrire de HTML ou de CSS.
Le projet fonctionne comme un synchronisateur d'état collaboratif, relayant et persistant l'état de l'application à travers plusieurs utilisateurs simultanés pour permettre des expériences partagées en temps réel. Il se distingue en diffusant des mises à jour en direct et des visualisations de données vers les navigateurs connectés via un modèle de programmation unifié.
Le framework couvre un large éventail de capacités, incluant la création de mises en page responsives, de formulaires de saisie interactifs et de visualisations de données. Il inclut des outils pour gérer le routage des applications, le rendu de tableaux de données et la construction d'interfaces de chat conversationnel.
Les utilisateurs peuvent amorcer de nouveaux projets en utilisant des modèles prédéfinis ou importer une bibliothèque d'exemples d'applications pour servir d'implémentations de référence.
Features
- Server-Side State Stores - Implements a server-side state synchronizer that coordinates shared real-time experiences across multiple concurrent users.
- Web Application Development - Provides a full-stack system for building web applications with integrated server, routing, and state management.
- Application State Syncing - Relays information through a central server to enable shared collaborative features like whiteboards.
- Application State Management - Provides systems for managing and synchronizing application-wide state across the server and client.
- Application State Synchronizations - Maintains real-time state consistency between a backend server and web browsers for low-latency interactivity.
- Application State Syncs - Broadcasts state updates to all connected clients to ensure a consistent real-time experience.
- Data Science Prototyping Tools - Provides environments for rapidly converting data analysis scripts into interactive web-based applications.
- Collaborative Application SDKs - Implements SDKs for building multiplayer features with real-time synchronization of application state.
- Bi-directional Data Sync - Enables real-time exchange of data and graphics between server and client via persistent connections.
- Realtime Interface Updates - Pushes immediate state changes to the user interface to ensure users view current information without reloading.
- Collaborative State Synchronization - Uses WebSocket servers to broadcast messages and synchronize application state across connected clients in real time.
- Analytical Dashboards - Enables the creation of real-time analytical dashboards using high-level languages without manual markup.
- Collaborative Interaction Sync - Synchronizes real-time user inputs and application state across multiple shared sessions to enable collaborative experiences.
- Data Visualization Libraries - Generates various charts including line and area plots with options for grouping and annotations.
- Interactive Dashboards - Builds interactive dashboards by organizing visual data components and built-in widgets for monitoring metrics.
- Data Visualization Interfaces - Integrates and displays interactive charts and graphics from data science and plotting libraries within the web interface.
- UI Component Integrations - Provides a library of pre-built interface elements and widgets to accelerate application development.
- User Interface Components - Offers a library of reusable layout components and widgets to build interfaces without writing HTML or CSS.
- Web Dashboards - Enables the creation of multi-page web dashboards using layout cards to visualize data.
- Backend-Driven UI Definitions - Allows developers to describe browser interfaces using Python or R without writing manual HTML or CSS.
- Backend-Driven UI Rendering - Creates browser-based user interfaces using high-level programming languages without requiring manual HTML or CSS.
- Browser-Based App Frameworks - Enables the creation of interactive web dashboards and applications using Python or R instead of manual HTML and CSS.
- Server-Side Event Handlers - Provides server-side event handlers that process real-time interactions from the browser without page reloads.
- Full-Stack Web Frameworks - Provides a comprehensive framework for building complete web applications with server-side state and client synchronization.
- Python and R Web Frameworks - Allows building real-time web applications and dashboards using either Python or R.
- Plotting-Library Renderers - Translates plotting and machine learning library definitions into interactive visual components in a web interface.
- Python Data Dashboard Frameworks - Provides a specialized framework for building data-driven dashboards using Python.
- Reactive UI Synchronization - Automatically updates user interface elements in response to changes in the underlying server-side data model.
- Real-Time - Provides a tool for creating interactive analytics dashboards that broadcast live updates and visualizations to browsers.
- Server-Controlled Browser State - Provides a unified programming model to manage the state and content of all connected web browsers from the server.
- WebSocket State Synchronization - Maintains real-time consistency between server and client by pushing state updates over WebSockets.
- Reactive Bindings - Implements content templates with placeholders that automatically update when the underlying data changes.
- Real-Time Data Pushing - Broadcasts live data and notifications to connected clients instantly via WebSocket push mechanisms.
- Live Preview UI Development - Provides live previews of application updates in the browser to accelerate the development iteration process.
- Server-Side Dynamic Page Generation - Synchronizes page content by merging server-side data updates with the live browser view.
- User Interaction - Captures client-side user interactions such as button clicks to trigger corresponding backend logic.
- Metrics Visualizers - Ships statistical widgets like gauges and bars to visualize performance indicators and numerical data.
- Analytical Application Prototyping - Allows for the rapid prototyping of decision-support applications and analytical tools using visualization components.
- Chart Components - Generates a wide array of charts including line, bar, and polar plots with annotations.
- Component-Based UI Libraries - Provides a library of reusable interface elements and APIs to accelerate the construction of user interfaces.
- Data Tables - Displays structured data in tabular formats with built-in support for sorting, filtering, pagination, and grouping.
- Component Layout Engines - Ships a layout engine that arranges interactive widgets on a coordinate grid for responsive dashboards.
- Layout Containers - Arranges application content using high-level layout containers like headers, footers, and navigation bars.
- Form and Input Management - Provides systems for handling user input through a variety of interactive form components.
- Form Input Components - Provides a library of UI elements for capturing user input via text boxes, sliders, and file uploaders.
- Interactive Form Controls - Provides a collection of interactive form controls including text boxes, date pickers, and sliders.
- Dashboard Metric Displays - Renders key performance indicators using specialized dashboard cards featuring numeric values and sparkline charts.
- Page Layout Frameworks - Organizes the overall application structure using consistent containers, toolbars, tabs, and breadcrumbs.
- Chat Interface Components - Implements conversational components with message streaming and suggestion chips for real-time communication.
- Responsive Grid Layouts - Provides layout systems that adapt fluidly across screen sizes using grid-based structures.
- Responsive Layout Containers - Arranges headers, footers, and toolbars using responsive containers to organize application elements.
- Application Route Managers - Manages application navigation and URL states to handle view transitions in a single-page experience.
- Asynchronous Content Updates - Provides a mechanism to refresh UI content via server pushes without requiring a full page reload.
- Web Framework Route Handlers - Maps specific URL patterns to handler functions to manage application routing.
- Dynamic Site Structure Management - Controls the application structure by adding new cards or removing entire pages from a site.
- Grid-Based Page Builders - Creates browser-based pages using content blocks and widgets positioned on a coordinate grid.
- Hash-Based Routing - Implements hash-based routing to manage application navigation and view transitions without page reloads.
- Server-Side Page State Persistence - Retains page content on a server so visitors can view the state asynchronously.
- Reactive Binding Updates - Uses reactive binding to automatically refresh UI content when the underlying server-side data changes.
- Dashboards and BI - Framework for building realtime web apps and dashboards.
- Outils de développement - Framework for building real-time web apps and dashboards.
- Python Projects - Listed in the “Python Projects” section of the Awesome For Beginners awesome list.
